pyTEMlib 0.2025.4.1__py3-none-any.whl → 0.2025.9.1__py3-none-any.whl

pyTEMlib/get_bote_salvat.py

@@ -0,0 +1,69 @@
+""" Convert Bote and Salvat cross sections to json format
+    Data from:  Bote and Salvat (1998)  Atomic Data and Nuclear Data Tables 71, 1-15
+"""
+
+
+import json
+import os
+import sys
+
+import numpy as np
+
+sys.path.insert(0, './')
+import pyTEMlib
+print(pyTEMlib.__version__)
+
+def write_bote_salvat_json():
+    """ Convert Bote and Salvat cross sections to json format"""
+    line = 'not empty'
+    x_sec = {}
+    with open('.//data//Bote_Salvat.txt', 'r', encoding='utf-8') as f:
+        while line:
+            line = f.readline()
+            if 'BoteSalvatElementDatum' in line:
+                ele = line.split('[')
+                z = int(ele[0].split('(')[1][:-2])
+                be = []
+                for value in ele[1].split(']')[0].split(','):
+                    be.append(float(value))
+                x_sec[z]= {'Be': be}
+                current_x = x_sec[z]
+            else:
+                if 'Anlj' not in current_x.keys():
+                    alij = []
+                    for value in line.split('[')[1].split(']')[0].split(','):
+                        alij.append(float(value))
+                    current_x['Anlj'] = alij
+                elif 'G' not in current_x.keys():
+                    g = []
+                    gg = []
+                    g_lines =line.split('[')[1].split(']')[0].split(';')
+                    for g_line in g_lines:
+                        g = []
+                        for value in g_line.split(' '):
+                            if value != '':
+                                g.append(float(value))
+                        gg.append(g)
+                    current_x['G'] = gg
+                elif 'edge' not in current_x.keys():
+                    edge = []
+                    for value in line.split('[')[1].split(']')[0].split(','):
+                        edge.append(float(value))
+                    current_x['edge'] = edge
+                elif 'A' not in current_x.keys():
+                    a = []
+                    aa = []
+                    a_lines =line.split('[')[1].split(']')[0].split(';')
+                    for a_line in a_lines:
+                        a = []
+                        for value in a_line.split(' '):
+                            if value != '':
+                                a.append(float(value))
+                        aa.append(a)
+                    current_x['A'] = aa
+        for key, value in x_sec[3].items():
+            print(key, np.array(value))
+
+
+    file_name_out = os.path.join(pyTEMlib.config_path, 'Bote_Salvat.json')
+    json.dump(x_sec, open(file_name_out, 'w', encoding='utf-8'), indent=4)

pyTEMlib/graph_tools.py

@@ -2,17 +2,9 @@
 
 """
 import numpy as np
-# import ase
-import sys
+import scipy
+import skimage
 
-import scipy.spatial
-import scipy.optimize
-import scipy.interpolate
-
-from skimage.measure import grid_points_in_poly, points_in_poly
-
-# import plotly.graph_objects as go
-# import plotly.express as px
 import matplotlib.patches as patches
 
 import pyTEMlib.crystal_tools
@@ -546,137 +538,6 @@ def get_bonds(crystal, shift= 0., verbose = False, cheat=1.0):
     atoms.info.update({'supercell': crystal})
     return atoms    
 
-def plot_atoms(atoms: ase.Atoms, polyhedra_indices=None, plot_bonds=False, color='', template=None, atom_size=None, max_size=35) -> go.Figure:
-    """
-    Plot structure in a ase.Atoms object with plotly
-    
-    If the info dictionary of the atoms object contains bond or polyedra information, these can be set tobe plotted
-    
-    Partameter:
-    -----------
-    atoms: ase.Atoms object
-        structure of supercell
-    polyhedra_indices: list of integers
-        indices of polyhedra to be plotted
-    plot_bonds: boolean
-        whether to plot bonds or not
-
-    Returns:
-    --------
-    fig: plotly figure object
-        handle to figure needed to modify appearance
-    """
-    energies = np.zeros(len(atoms))
-    if 'bonds' in atoms.info:
-        if 'atom_energy' in atoms.info['bonds']:
-            energies = np.round(np.array(atoms.info['bonds']['atom_energy'] - 12 * atoms.info['bonds']['ideal_bond_energy']) *1000,0)
-    
-            for atom in atoms:
-                if atom.index not in atoms.info['bonds']['super_cell_atoms']:
-                    energies[atom.index] = 0.
-    if color == 'coordination':
-        colors = atoms.info['bonds']['coordination']
-    elif color == 'layer':
-        colors = atoms.positions[:, 2]
-    elif color == 'energy':
-        colors = energies
-        colors[colors>50] = 50
-        colors = np.log(1+ energies)
-        
-    else: 
-        colors = atoms.get_atomic_numbers()
-        
-    if atom_size is None:
-        atom_size = atoms.get_atomic_numbers()*4
-    elif isinstance(atom_size, float):
-        atom_size = atoms.get_atomic_numbers()*4*atom_size
-        atom_size[atom_size>max_size] = max_size
-    elif isinstance(atom_size, int):
-        atom_size = [atom_size]*len(atoms)
-    if len(atom_size) !=  len(atoms):
-        atom_size = [10]*len(atoms)
-        print('wrong length of atom_size parameter')
-    plot_polyhedra = False
-    data = []
-    if polyhedra_indices is not None:
-        if 'polyhedra' in atoms.info:   
-            if polyhedra_indices == -1:
-                data = plot_polyhedron(atoms.info['polyhedra']['polyhedra'], range(len(atoms.info['polyhedra']['polyhedra'])))
-                plot_polyhedra = True
-            elif isinstance(polyhedra_indices, list):
-                data = plot_polyhedron(atoms.info['polyhedra']['polyhedra'], polyhedra_indices)
-                plot_polyhedra = True
-    text = []
-    if 'bonds' in atoms.info:
-        coord = atoms.info['bonds']['coordination']
-        for atom in atoms:
-            if atom.index in atoms.info['bonds']['super_cell_atoms']:
-
-                text.append(f'Atom {atom.index}: coordination={coord[atom.index]}' +
-                            f'x:{atom.position[0]:.2f} \n y:{atom.position[1]:.2f} \n z:{atom.position[2]:.2f}')
-                if 'atom_energy' in atoms.info['bonds']:
-                    text[-1] += f"\n energy: {energies[atom.index]:.0f} meV"
-            else:
-                text.append('')
-    else: 
-        text = [''] * len(atoms)
-          
-    if plot_bonds:
-         data += get_plot_bonds(atoms)
-    if plot_polyhedra or plot_bonds:
-        fig = go.Figure(data=data)
-    else:
-        fig = go.Figure()
-    if color=='energy':
-        fig.add_trace(go.Scatter3d(
-                        mode='markers',
-                        x=atoms.positions[:,0], y=atoms.positions[:,1], z=atoms.positions[:,2],
-                        hovertemplate='<b>%{text}</b><extra></extra>',
-                        text = text,
-                        marker=dict(
-                            color=colors,
-                            size=atom_size,
-                            sizemode='diameter',
-                            colorscale='Rainbow', #px.colors.qualitative.Light24,
-                            colorbar=dict(thickness=10, orientation='h'))))
-                            #hover_name = colors)))  # ["blue", "green", "red"])))        
-    
-    elif 'bonds' in atoms.info:
-        fig.add_trace(go.Scatter3d(
-                        mode='markers',
-                        x=atoms.positions[:,0], y=atoms.positions[:,1], z=atoms.positions[:,2],
-                        hovertemplate='<b>%{text}</b><extra></extra>',
-                        text = text,
-                        marker=dict(
-                            color=colors,
-                            size=atom_size,
-                            sizemode='diameter',
-                            colorscale= px.colors.qualitative.Light24)))
-                            #hover_name = colors)))  # ["blue", "green", "red"])))         
-            
-    else:
-         fig.add_trace(go.Scatter3d(
-                        mode='markers',
-                        x=atoms.positions[:,0], y=atoms.positions[:,1], z=atoms.positions[:,2],
-                        marker=dict(
-                            color=colors,
-                            size=atom_size,
-                            sizemode='diameter',
-                            colorbar=dict(thickness=10),
-                            colorscale= px.colors.qualitative.Light24)))
-                            #hover_name = colors)))  # ["blue", "green", "red"])))         
-    fig.update_layout(width=1000, height=700, showlegend=False, template=template)
-    fig.update_layout(scene_aspectmode='data',
-                      scene_aspectratio=dict(x=1, y=1, z=1))
-
-    camera = {'up': {'x': 0, 'y': 1, 'z': 0},
-              'center': {'x': 0, 'y': 0, 'z': 0},
-              'eye': {'x': 0, 'y': 0, 'z': 1}}
-    fig.update_coloraxes(showscale=True)
-    fig.update_layout(scene_camera=camera, title=r"Al-GB $")
-    fig.update_scenes(camera_projection_type="orthographic" ) 
-    fig.show()
-    return fig
 
 
 
@@ -780,7 +641,7 @@ def sort_polyhedra_by_vertices(polyhedra, visible=range(4, 100), z_lim=[0, 100],
 ##########################
 # New Graph Stuff
 ##########################
-def breadth_first_search2(graph, initial, projected_crystal):
+def breadth_first_search(graph, initial_node_index, projected_crystal):
     """ breadth first search of atoms viewed as a graph
 
     the projection dictionary has to contain the following items
@@ -808,7 +669,7 @@ def breadth_first_search2(graph, initial, projected_crystal):
         a_lattice_vector = projection_tags['lattice_vector']['a']
         b_lattice_vector = projection_tags['lattice_vector']['b']
         main = np.array([a_lattice_vector, -a_lattice_vector, b_lattice_vector, -b_lattice_vector])  # vectors of unit cell
-        near = []
+        near =  main
     else:
         # get lattice vectors to hopp along through graph
         projected_unit_cell = projected_crystal.cell[:2, :2]
@@ -816,19 +677,17 @@ def breadth_first_search2(graph, initial, projected_crystal):
         b_lattice_vector = projected_unit_cell[1]
         main = np.array([a_lattice_vector, -a_lattice_vector, b_lattice_vector, -b_lattice_vector])  # vectors of unit cell
         near = projection_tags['near_base']  # all nearest atoms
-    # get k next nearest neighbours for each node
-    main = np.array([a_lattice_vector, -a_lattice_vector, b_lattice_vector, -b_lattice_vector])  # vectors of unit cell
-    near = np.append(main, near, axis=0) 
-
+        near = np.append(main, near, axis=0) 
+    
     neighbour_tree = scipy.spatial.KDTree(graph)
-    distances, indices = neighbour_tree.query(graph,  # let's get all neighbours
-                                              k=50)  # projection_tags['number_of_nearest_neighbours']*2 + 1)
-    # print(projection_tags['number_of_nearest_neighbours'] * 2 + 1)
+    distances, indices = neighbour_tree.query(graph,  k=50) # let's get all neighbours
+                                                
+    
     visited = []  # the atoms we visited
     ideal = []  # atoms at ideal lattice
     sub_lattice = []  # atoms in base and disregarded
-    queue = [initial]
-    ideal_queue = [graph[initial]]
+    queue = [initial_node_index]
+    ideal_queue = [graph[initial_node_index]]
 
     while queue:
         node = queue.pop(0)
@@ -842,7 +701,6 @@ def breadth_first_search2(graph, initial, projected_crystal):
             for i, neighbour in enumerate(neighbors):
                 if neighbour not in visited:
                     distance_to_ideal = np.linalg.norm(near + graph[node] - graph[neighbour], axis=1)
-
                     if np.min(distance_to_ideal) < projection_tags['allowed_variation']:
                         direction = np.argmin(distance_to_ideal)
                         if direction > 3:  # counting starts at 0
@@ -854,11 +712,93 @@ def breadth_first_search2(graph, initial, projected_crystal):
     return graph[visited], ideal
 
 
+def get_base_atoms(graph, origins, base, tolerance=3):
+    """ get sublattices of atoms in a graph
+    This function returns the indices of atoms in a graph that are close to the base atoms.
+    Parameters
+    ----------  
+    graph: numpy array (Nx2)
+        the atom positions
+    origins: numpy array (Nx2)
+        the origin positions
+    base: numpy array (Mx2)
+        the base atom positions
+    tolerance: float
+        the distance tolerance for finding base atoms
+    Returns
+    -------
+    sublattices: list of numpy arrays
+        list of indices of atoms in the graph that are close to each base atom
+    """
+    sublattices = []
+    neighbour_tree = scipy.spatial.KDTree(graph)
+    for base_atom in base:
+         distances, indices = neighbour_tree.query(origins+base_atom[:2], k=50) 
+         sublattices.append(indices[distances < tolerance]) 
+    return sublattices
+
+def analyze_atomic_structure(dataset, crystal, start_atom_index, tolerance=1.5):
+    """ Analyze atomic structure of a crystal and return sublattices of atoms
+
+    Parameters
+    ----------
+    dataset: pyTEMlib.Dataset
+        dataset containing the atomic structure information
+    crystal: ase.Atoms
+        crystal structure to analyze
+    start_atom_index: int
+        index of the starting atom for the breadth-first search
+    tolerance: float
+        tolerance for determining the allowed variation in atom positions
+    Returns
+    -------
+    sublattices: list of numpy arrays
+        list of indices of atoms in the graph that are close to each base atom
+    """
+    if 'atoms' not in dataset.metadata:
+        TypeError('dataset.metadata needs to contain atoms information')
+        
+    graph = dataset.metadata['atoms']['positions']
+    
+    layer = pyTEMlib.crystal_tools.get_projection(crystal)
+    gamma = np.radians(layer.cell.angles()[2])
+    rotation_angle = np.radians(crystal.info['experimental']['angle']
+)
+    length = (layer.cell.lengths() /10/dataset.x.slope)[:2]
+    print(length, rotation_angle, gamma)
+    a = np.array([np.cos(rotation_angle)*length[0], np.sin(rotation_angle)*length[0]])
+    b = np.array([np.cos(rotation_angle+gamma)*length[1], np.sin(rotation_angle+gamma)*length[1]])
+    base = layer.get_scaled_positions()
+    base[:, :2] = np.dot(base[:, :2],[a,b])
+    projection_tags = {'lattice_vector': {'a': a, 'b': b},
+                       'allowed_variation': tolerance,
+                       'distance_unit_cell':  np.max(length)*1.04,
+                       'start_atom_index': start_atom_index,
+                       'base': base}
+    layer.info['projection'] = projection_tags
+
+    origins, ideal = pyTEMlib.graph_tools.breadth_first_search(graph[:,:2], start_atom_index, layer)
+    print(len(origins), 'origins found')
+    dataset.metadata['atoms']['projection'] = layer
+    sublattices = pyTEMlib.graph_tools.get_base_atoms(graph[:, :2], origins, base[:, :2], tolerance=3)
+    
+    dataset.metadata['atoms']['origins'] = origins
+    dataset.metadata['atoms']['ideal_origins'] = ideal
+    dataset.metadata['atoms']['sublattices'] = sublattices
+    dataset.metadata['atoms']['projection_tags'] = projection_tags
+    
+    return sublattices
+
 
-def breadth_first_search_felxible(graph, initial, lattice_parameter, tolerance=1):
+def breadth_first_search_felxible(graph, initial_node_index, lattice_parameter, tolerance=1):
     """ breadth first search of atoms viewed as a graph
         This is a rotational invariant search of atoms in a lattice, and returns the angles of unit cells.
         We only use the ideal lattice parameter to determine the lattice.  
+
+    Parameters
+    ----------
+    graph: numpy array (Nx2)        
+
     """
     if isinstance(lattice_parameter, ase.Atoms):
         lattice_parameter = lattice_parameter.cell.lengths()[:2]
@@ -867,12 +807,11 @@ def breadth_first_search_felxible(graph, initial, lattice_parameter, tolerance=1
     lattice_parameter = np.array(lattice_parameter)
 
     neighbour_tree = scipy.spatial.KDTree(graph)
-    distances, indices = neighbour_tree.query(graph,  # let's get all neighbours
-                                              k=50)  # projection_tags['number_of_nearest_neighbours']*2 + 1)
+    distances, indices = neighbour_tree.query(graph,  k=50) # let's get all neighbours
     visited = []  # the atoms we visited
     angles = []  # atoms at ideal lattice
     sub_lattice = []  # atoms in base and disregarded
-    queue = [initial]
+    queue = [initial_node_index]
     queue_angles=[0]
     
     while queue:
@@ -921,12 +860,7 @@ def get_distortion_matrix(atoms, ideal_lattice):
     ideal_vertices = get_significant_vertices(ideal_vertices - np.average(ideal_vertices, axis=0))
 
     distortion_matrix = []
-    for index in range(vor.points.shape[0]):
-        done = int((index + 1) / vor.points.shape[0] * 50)
-        sys.stdout.write('\r')
-        # progress output :
-        sys.stdout.write("[%-50s] %d%%" % ('=' * done, 2 * done))
-        sys.stdout.flush()
+    for index in trange(vor.points.shape[0]):
 
         # determine vertices of Voronoi polygons of an atom with number index
         poly_point = vor.points[index]
@@ -1015,7 +949,7 @@ def transform_voronoi(vertices, ideal_voronoi):
     polygon_grid = np.swapaxes(polygon_grid, 0, 2)
     polygon_array = polygon_grid.reshape(-1, polygon_grid.shape[-1])
 
-    p = points_in_poly(polygon_array, vertices2)
+    p = skimage.measure.points_in_poly(polygon_array, vertices2)
     uncorrected = polygon_array[p]
 
     corrected = np.dot(uncorrected, aa)
@@ -1102,7 +1036,7 @@ def transform_voronoi(vertices, ideal_voronoi):
     polygon_grid = np.swapaxes(polygon_grid, 0, 2)
     polygon_array = polygon_grid.reshape(-1, polygon_grid.shape[-1])
 
-    p = points_in_poly(polygon_array, vertices2)
+    p = skimage.measure.points_in_poly(polygon_array, vertices2)
     uncorrected = polygon_array[p]
 
     corrected = np.dot(uncorrected, aa)
@@ -1211,16 +1145,9 @@ def undistort_stack(distortion_matrix, data):
     nimages = data.shape[0]
     done = 0
 
-    
-    for i in range(nimages):
-        done = int((i + 1) / nimages * 50)
-        sys.stdout.write('\r')
-        # progress output :
-        sys.stdout.write("[%-50s] %d%%" % ('=' * done, 2 * done))
-        sys.stdout.flush()
-
+    for i in trange(nimages):
         interpolated[i, :, :] = griddata(corrected, intensity_values[i, :], (grid_x, grid_y), method='linear')
-    
+
     print(':-)')
     print('You have successfully completed undistortion of image stack')
     return interpolated

pyTEMlib/graph_viz.py

@@ -19,6 +19,156 @@ import pyTEMlib.crystal_tools
 import pyTEMlib.graph_tools
 
 
+def get_plot_bonds(atoms):
+    """Get plotly data for bonds."""
+    connectivity_matrix = atoms.info['bonds']['connectivity_matrix']
+    data = []
+    for row in range(1, connectivity_matrix.shape[0]):
+        for column in range(row):
+            if connectivity_matrix[column, row]:
+                lines = dict(type='scatter3d',
+                     x=atoms.positions[[column, row],0],
+                     y=atoms.positions[[column, row],1],
+                     z=atoms.positions[[column, row],2],
+                     mode='lines',
+                     name='',
+                     line=dict(color='rgb(70,70,70)', width=1.5))
+                data.append(lines)
+    return data
+
+def plot_atoms(atoms: ase.Atoms, polyhedra_indices=None, plot_bonds=False, color='', template=None, atom_size=None, max_size=35) -> go.Figure:
+    """
+    Plot structure in a ase.Atoms object with plotly
+    
+    If the info dictionary of the atoms object contains bond or polyedra information, these can be set tobe plotted
+    
+    Partameter:
+    -----------
+    atoms: ase.Atoms object
+        structure of supercell
+    polyhedra_indices: list of integers
+        indices of polyhedra to be plotted
+    plot_bonds: boolean
+        whether to plot bonds or not
+
+    Returns:
+    --------
+    fig: plotly figure object
+        handle to figure needed to modify appearance
+    """
+    energies = np.zeros(len(atoms))
+    if 'bonds' in atoms.info:
+        if 'atom_energy' in atoms.info['bonds']:
+            energies = np.round(np.array(atoms.info['bonds']['atom_energy'] - 12 * atoms.info['bonds']['ideal_bond_energy']) *1000,0)
+    
+            for atom in atoms:
+                if atom.index not in atoms.info['bonds']['super_cell_atoms']:
+                    energies[atom.index] = 0.
+    if color == 'coordination':
+        colors = atoms.info['bonds']['coordination']
+    elif color == 'layer':
+        colors = atoms.positions[:, 2]
+    elif color == 'energy':
+        colors = energies
+        colors[colors>50] = 50
+        colors = np.log(1+ energies)
+        
+    else: 
+        colors = atoms.get_atomic_numbers()
+        
+    if atom_size is None:
+        atom_size = atoms.get_atomic_numbers()*4
+    elif isinstance(atom_size, float):
+        atom_size = atoms.get_atomic_numbers()*4*atom_size
+        atom_size[atom_size>max_size] = max_size
+    elif isinstance(atom_size, int):
+        atom_size = [atom_size]*len(atoms)
+    if len(atom_size) !=  len(atoms):
+        atom_size = [10]*len(atoms)
+        print('wrong length of atom_size parameter')
+    plot_polyhedra = False
+    data = []
+    if polyhedra_indices is not None:
+        if 'polyhedra' in atoms.info:   
+            if polyhedra_indices == -1:
+                data = plot_polyhedron(atoms.info['polyhedra']['polyhedra'], range(len(atoms.info['polyhedra']['polyhedra'])))
+                plot_polyhedra = True
+            elif isinstance(polyhedra_indices, list):
+                data = plot_polyhedron(atoms.info['polyhedra']['polyhedra'], polyhedra_indices)
+                plot_polyhedra = True
+    text = []
+    if 'bonds' in atoms.info:
+        coord = atoms.info['bonds']['coordination']
+        for atom in atoms:
+            if atom.index in atoms.info['bonds']['super_cell_atoms']:
+
+                text.append(f'Atom {atom.index}: coordination={coord[atom.index]}' +
+                            f'x:{atom.position[0]:.2f} \n y:{atom.position[1]:.2f} \n z:{atom.position[2]:.2f}')
+                if 'atom_energy' in atoms.info['bonds']:
+                    text[-1] += f"\n energy: {energies[atom.index]:.0f} meV"
+            else:
+                text.append('')
+    else: 
+        text = [''] * len(atoms)
+          
+    if plot_bonds:
+         data += get_plot_bonds(atoms)
+    if plot_polyhedra or plot_bonds:
+        fig = go.Figure(data=data)
+    else:
+        fig = go.Figure()
+    if color=='energy':
+        fig.add_trace(go.Scatter3d(
+                        mode='markers',
+                        x=atoms.positions[:,0], y=atoms.positions[:,1], z=atoms.positions[:,2],
+                        hovertemplate='<b>%{text}</b><extra></extra>',
+                        text = text,
+                        marker=dict(
+                            color=colors,
+                            size=atom_size,
+                            sizemode='diameter',
+                            colorscale='Rainbow', #px.colors.qualitative.Light24,
+                            colorbar=dict(thickness=10, orientation='h'))))
+                            #hover_name = colors)))  # ["blue", "green", "red"])))        
+    
+    elif 'bonds' in atoms.info:
+        fig.add_trace(go.Scatter3d(
+                        mode='markers',
+                        x=atoms.positions[:,0], y=atoms.positions[:,1], z=atoms.positions[:,2],
+                        hovertemplate='<b>%{text}</b><extra></extra>',
+                        text = text,
+                        marker=dict(
+                            color=colors,
+                            size=atom_size,
+                            sizemode='diameter',
+                            colorscale= px.colors.qualitative.Light24)))
+                            #hover_name = colors)))  # ["blue", "green", "red"])))         
+            
+    else:
+         fig.add_trace(go.Scatter3d(
+                        mode='markers',
+                        x=atoms.positions[:,0], y=atoms.positions[:,1], z=atoms.positions[:,2],
+                        marker=dict(
+                            color=colors,
+                            size=atom_size,
+                            sizemode='diameter',
+                            colorbar=dict(thickness=10),
+                            colorscale= px.colors.qualitative.Light24)))
+                            #hover_name = colors)))  # ["blue", "green", "red"])))         
+    fig.update_layout(width=1000, height=700, showlegend=False, template=template)
+    fig.update_layout(scene_aspectmode='data',
+                      scene_aspectratio=dict(x=1, y=1, z=1))
+
+    camera = {'up': {'x': 0, 'y': 1, 'z': 0},
+              'center': {'x': 0, 'y': 0, 'z': 0},
+              'eye': {'x': 0, 'y': 0, 'z': 1}}
+    fig.update_coloraxes(showscale=True)
+    fig.update_layout(scene_camera=camera, title=r"Al-GB $")
+    fig.update_scenes(camera_projection_type="orthographic" ) 
+    fig.show()
+    return fig
+
+
 def plot_super_cell(super_cell, shift_x=0.):
     """ make a super_cell to plot with extra atoms at periodic boundaries"""
 

pyTEMlib/image/__init__.py

@@ -0,0 +1,37 @@
+"""
+Image Module
+
+Should contain
+- general feature extraction
+- geometry feature extraction
+- atom finding
+- denoising
+- windowing
+- transforms (e.g., radon, hough)
+
+Submodules
+----------
+.. autosummary::
+    :toctree: _autosummary
+
+"""
+ 
+from .image_window import ImageWindowing
+from .image_utilities import crop_image, flatten_image, inpaint_image, warp, rebin
+from .image_clean import decon_lr, clean_svd, background_correction
+from .image_atoms import find_atoms, atom_refine, intensity_area, atoms_clustering
+from .image_graph import find_polyhedra, breadth_first_search, breadth_first_search_flexible
+from .image_graph import get_base_atoms
+from .image_distortion import get_distortion_matrix, undistort, undistort_sitk
+from .image_registration import complete_registration, rigid_registration, demon_registration
+from .image_fft import power_spectrum, diffractogram_spots, adaptive_fourier_filter
+from .image_fft import rotational_symmetry_diffractogram
+
+
+__all__ = ['ImageWindowing', 'crop_image', 'decon_lr', 'clean_svd', 'background_correction',
+           'find_atoms', 'atom_refine', 'intensity_area', 'atoms_clustering',  
+           'find_polyhedra', 'breadth_first_search', 'breadth_first_search_flexible', 'get_base_atoms',
+           'get_distortion_matrix', 'undistort', 'undistort_sitk',
+           'complete_registration', 'demon_registration', 'rigid_registration', 
+           'flatten_image', 'inpaint_image', 'warp', 'rebin',
+           'power_spectrum', 'diffractogram_spots', 'adaptive_fourier_filter', 'rotational_symmetry_diffractogram']