pyTEMlib 0.2025.2.2__tar.gz → 0.2025.4.0__tar.gz

{pytemlib-0.2025.2.2/pyTEMlib.egg-info → pytemlib-0.2025.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyTEMlib
-Version: 0.2025.2.2
+Version: 0.2025.4.0
 Summary: pyTEM: TEM Data Quantification library through a model-based approach
 Home-page: https://pycroscopy.github.io/pyTEMlib/about.html
 Author: Gerd Duscher
@@ -39,7 +39,7 @@ Requires-Dist: spglib
 Requires-Dist: scikit-image
 Requires-Dist: scikit-learn
 Requires-Dist: pyNSID>=0.0.7
-Requires-Dist: sidpy>=0.12.1
+Requires-Dist: sidpy>=0.12.7
 Requires-Dist: SciFiReaders>=0.0.8
 Dynamic: author
 Dynamic: author-email
@@ -48,6 +48,7 @@ Dynamic: description
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: platform
 Dynamic: requires-dist
 Dynamic: summary

{pytemlib-0.2025.2.2 → pytemlib-0.2025.4.0}/pyTEMlib/atom_tools.py

@@ -61,6 +61,8 @@ def find_atoms(image, atom_size=0.1, threshold=0.):
         threshold = np.std(im)
     atoms = blob_log(im, max_sigma=atom_size/scale_x, threshold=threshold)
 
+    
+
     return atoms
 
 

{pytemlib-0.2025.2.2 → pytemlib-0.2025.4.0}/pyTEMlib/core_loss_widget.py

@@ -500,8 +500,7 @@ class CoreLoss(object):
             self.core_loss_tab[11, 0].value = edge['areal_density']
             self.core_loss_tab[11, 2].value = 'a.u.'
         else:
-            dispersion = self.parent.energy_scale[1] - \
-                self.parent.energy_scale[0]
+            dispersion = self.parent.energy_scale.slope
             self.core_loss_tab[11, 0].value = np.round(
                 edge['areal_density']/self.dataset.metadata['experiment']['flux_ppm']*1e-6, 2)
             self.core_loss_tab[11, 2].value = 'atoms/nm²'
@@ -663,8 +662,7 @@ class CoreLoss(object):
 
         edge['areal_density'] = self.core_loss_tab[11, 0].value
         if self.parent.y_scale != 1.0:
-            dispersion = self.parent.energy_scale[1] - \
-                self.parent.energy_scale[0]
+            dispersion = self.parent.energy_scale.slope
             edge['areal_density'] = self.core_loss_tab[11, 0].value * \
                 self.dataset.metadata['experiment']['flux_ppm']/1e-6
         if 'model' in self.edges:

{pytemlib-0.2025.2.2 → pytemlib-0.2025.4.0}/pyTEMlib/eels_dialog.py

@@ -335,7 +335,7 @@ class CompositionWidget(object):
         self.dd = (self.energy_scale[0], self.energy_scale[1])
 
         self.dataset.metadata['experiment']['offset'] = self.energy_scale[0]
-        self.dataset.metadata['experiment']['dispersion'] = self.energy_scale[1] - self.energy_scale[0]
+        self.dataset.metadata['experiment']['dispersion'] = self.spec_dim.slope
         if 'edges' not in self.dataset.metadata or self.dataset.metadata['edges'] == {}:
             self.dataset.metadata['edges'] = {'0': {}, 'model': {}, 'use_low_loss': False}
        

{pytemlib-0.2025.2.2 → pytemlib-0.2025.4.0}/pyTEMlib/eels_tools.py

@@ -42,7 +42,6 @@ from pyTEMlib.xrpa_x_sections import x_sections
 
 import sidpy
 from sidpy.proc.fitter import SidFitter
-from sidpy.base.num_utils import get_slope
 
 # we have a function called find peaks - is it necessary?
 # or could we just use scipy.signal import find_peaks
@@ -604,7 +603,8 @@ def fit_plasmon(dataset: Union[sidpy.Dataset, np.ndarray], startFitEnergy: float
         guess_pos = np.argmax(fit_dset)
         guess_amplitude = fit_dset[guess_pos]
         guess_width =(endFitEnergy-startFitEnergy)/4
-        guess_pos = energy[guess_pos]
+        guess_pos = energy[start_fit_pixel+guess_pos]
+        
         if guess_width >8:
             guess_width=8
         try:
@@ -618,7 +618,7 @@ def fit_plasmon(dataset: Union[sidpy.Dataset, np.ndarray], startFitEnergy: float
                                 p0=[guess_pos, guess_width, guess_amplitude])
             except:
                 popt=[0,0,0]
-       
+        
         plasmon = dataset.like_data(energy_loss_function(energy, popt[0], popt[1], popt[2]))
         plasmon *= anglog
         start_plasmon = np.searchsorted(energy, 0)+1
@@ -652,16 +652,16 @@ def fit_plasmon(dataset: Union[sidpy.Dataset, np.ndarray], startFitEnergy: float
 def angle_correction(spectrum):
 
     acceleration_voltage = spectrum.metadata['experiment']['acceleration_voltage']
-    energy_scale = spectrum.get_spectral_dims(return_axis=True)[0].values
+    energy_scale = spectrum.get_spectral_dims(return_axis=True)[0]
     # eff_beta = effective_collection_angle(energy_scale, spectrum.metadata['experiment']['convergence_angle'],
     #                                     spectrum.metadata['experiment']['collection_angle'],acceleration_voltage)
    
     
-    epc = energy_scale[1] - energy_scale[0]  # input('ev per channel : ');
+    epc = energy_scale.slope  # input('ev per channel : ');
 
     alpha = spectrum.metadata['experiment']['convergence_angle']  # input('Alpha (mrad) : ');
     beta = spectrum.metadata['experiment']['collection_angle']# input('Beta (mrad) : ');
-    e = energy_scale
+    e = energy_scale.values
     e0 = acceleration_voltage/1000 # input('E0 (keV) : ');
 
     T = 1000.0*e0*(1.+e0/1022.12)/(1.0+e0/511.06)**2  # %eV # equ.5.2a or Appendix E p 427 
@@ -1261,7 +1261,7 @@ def second_derivative(dataset: sidpy.Dataset, sensitivity: float=2.5) -> None:
     """Calculates second derivative of a sidpy.dataset"""
 
     dim = dataset.get_spectral_dims()
-    energy_scale = dataset.get_spectral_dims(return_axis=True)[0].values
+    energy_scale = dataset.get_spectral_dims(return_axis=True)[0]
     if dataset.data_type.name == 'SPECTRAL_IMAGE':
         spectrum = dataset.view.get_spectrum()
     else:
@@ -1269,7 +1269,7 @@ def second_derivative(dataset: sidpy.Dataset, sensitivity: float=2.5) -> None:
 
     spec = scipy.ndimage.gaussian_filter(spectrum, 3)
 
-    dispersion = get_slope(energy_scale)
+    dispersion = energy_scale.slope
     second_dif = np.roll(spec, -3) - 2 * spec + np.roll(spec, +3)
     second_dif[:3] = 0
     second_dif[-3:] = 0
@@ -1405,8 +1405,9 @@ def identify_edges(dataset: sidpy.Dataset, noise_level: float=2.0):
     
     """
     dim = dataset.get_spectral_dims()
-    energy_scale = dataset.get_spectral_dims(return_axis=True)[0].values
-    dispersion = get_slope(energy_scale)
+    energy_scale = dataset.get_spectral_dims(return_axis=True)[0]
+    dispersion = energy_scale.slope
+    
     spec = scipy.ndimage.gaussian_filter(dataset, 3/dispersion)  # smooth with 3eV wideGaussian
 
     first_derivative = spec - np.roll(spec, +2) 

{pytemlib-0.2025.2.2 → pytemlib-0.2025.4.0}/pyTEMlib/file_tools.py

@@ -23,6 +23,9 @@ import ase.io
 import SciFiReaders
 import pyNSID
 import sidpy
+import sidpy
+import xml.etree.ElementTree as ET
+import collections
 import ipywidgets as widgets
 from IPython.display import display
 
@@ -33,8 +36,6 @@ import pyTEMlib.crystal_tools
 from pyTEMlib.config_dir import config_path
 from pyTEMlib.sidpy_tools import *
 
-from pyTEMlib.sidpy_tools import *
-
 Qt_available = True
 try:
     from PyQt5 import QtCore, QtWidgets, QtGui
@@ -44,8 +45,6 @@ except ModuleNotFoundError:
 
 Dimension = sidpy.Dimension
 
-# Austin commented the line below - it is not used anywhere in the code, and it gives import errors 9-14-2024
-# get_slope = sidpy.base.num_utils.get_slopes
 __version__ = '2024.9.14'
 
 from traitlets import Unicode, Bool, validate, TraitError
@@ -116,7 +115,6 @@ class FileWidget2(ipywidgets.DOMWidget):
                                             value='None',
                                             description='directory:',
                                             disabled=False,
-                                            button_style='',
                                             layout=widgets.Layout(width='90%'))
         
         
@@ -203,8 +201,7 @@ class FileWidget3(FileWidget2):
         self.loaded_datasets = widgets.Dropdown(options=self.dataset_list,
                                                 value=self.dataset_list[0],
                                                 description='loaded datasets:',
-                                                disabled=False,
-                                                button_style='')
+                                                disabled=False)
         
         ui = widgets.HBox([select_button, add_button, self.loaded_datasets])
         display(ui)
@@ -313,14 +310,12 @@ class FileWidget(ipywidgets.DOMWidget):
                                             value='None',
                                             description='directory:',
                                             disabled=False,
-                                            button_style='',
                                             layout=widgets.Layout(width='90%'))
         self.dataset_list = ['None']
         self.loaded_datasets = widgets.Dropdown(options=self.dataset_list,
                                                 value=self.dataset_list[0],
                                                 description='loaded datasets:',
-                                                disabled=False,
-                                                button_style='')
+                                                disabled=False)
         
         self.set_options()
         ui = widgets.VBox([self.path_choice, self.select_files, widgets.HBox([select_button, add_button,
@@ -446,8 +441,7 @@ class ChooseDataset(object):
         self.select_image = widgets.Dropdown(options=self.dataset_list,
                                              value=self.dataset_list[0],
                                              description='select dataset:',
-                                             disabled=False,
-                                             button_style='')
+                                             disabled=False)
         if show_dialog:
             display(self.select_image)
 
@@ -484,7 +478,7 @@ class ChooseDataset(object):
             self.dataset = self.datasets[self.key]
             self.dataset.title = self.dataset.title.split('/')[-1]
             self.dataset.title = self.dataset.title.split('/')[-1]
-
+    
 
 def add_to_dict(file_dict, name):
     full_name = os.path.join(file_dict['directory'], name)
@@ -884,7 +878,6 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False, sum_frames=Fa
         else:
             if isinstance(datasets, dict):
                 dataset_dict = datasets
-
             else:    
                 dataset_dict = {}
                 for index, dataset in enumerate(datasets):
@@ -926,23 +919,28 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False, sum_frames=Fa
                         dset.title = dset.title + '_SI'
                     dset = dset.T
                     dset.title = dset.title[11:]
+                    dset.add_provenance('pyTEMlib', 'open_file', version=pyTEMlib.__version__, linked_data='emi_converted_by_hyperspy')
                     dataset_dict[f'Channel_{index:03d}'] = dset
+
                 return dataset_dict
             except ImportError:
                 print('This file type needs hyperspy to be installed to be able to be read')
                 return
         elif extension == '.emd':
             reader = SciFiReaders.EMDReader(filename, sum_frames=sum_frames)
-            
+            provenance =  'SciFiReader.EMDReader'
         elif 'edax' in extension.lower():
             if 'h5' in extension:
                 reader = SciFiReaders.EDAXReader(filename)
+                provenance = 'SciFiReader.EDAXReader'
 
         elif extension in ['.ndata', '.h5']:
             reader = SciFiReaders.NionReader(filename)
-
+            provenance = 'SciFiReader.NionReader'
+           
         elif extension in ['.mrc']:
             reader = SciFiReaders.MRCReader(filename)
+            provenance = 'SciFiReader.MRCReader'
 
         else:
             raise NotImplementedError('extension not supported')
@@ -994,6 +992,7 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False, sum_frames=Fa
         if isinstance(dset, dict):
             dataset_dict = dset
             for dataset in dataset_dict.values():
+                dataset.add_provenance('pyTEMlib', 'open_file', version=pyTEMlib.__version__, linked_data = 'SciFiReader')
                 dataset.metadata['filename'] = filename
 
         elif isinstance(dset, list):
@@ -1431,6 +1430,97 @@ def h5_get_crystal_structure(structure_group):
     # ToDo: Read all of info dictionary
     return atoms
 
+import collections
+def etree_to_dict(element):
+    """Recursively converts an ElementTree object into a nested dictionary."""
+    d = {element.tag: {} if element.attrib else None}
+    children = list(element)
+    if children:
+        dd = collections.defaultdict(list)
+        for dc in map(etree_to_dict, children):
+            for k, v in dc.items():
+                dd[k].append(v)
+        d = {element.tag: {k: v[0] if len(v) == 1 else v for k, v in dd.items()}}
+    if element.attrib:
+        d[element.tag].update(('@' + k, v) for k, v in element.attrib.items())
+    if element.text:
+        text = element.text.strip()
+        if children or element.attrib:
+            if text:
+                d[element.tag]['#text'] = text
+        else:
+            d[element.tag] = text
+    return d
+
+def read_adorned_metadata(image):
+    xml_str = image.metadata.metadata_as_xml
+    root = ET.fromstring(xml_str)
+    metadata_dict = etree_to_dict(root)
+    detector = 'detector'
+    if 'Detectors' in metadata_dict['Metadata']['Detectors']['ScanningDetector']:
+        if 'ScanningDetector' in metadata_dict['Metadata']['Detectors']['ScanningDetector']:
+            detector = metadata_dict['Metadata']['Detectors']['ScanningDetector']['DetectorName']
+
+    segment = ''
+    if 'CustomPropertyGroup' in  metadata_dict['Metadata']:
+        if 'CustomProperties' in metadata_dict['Metadata']['CustomPropertyGroup']:
+            for list_item in metadata_dict['Metadata']['CustomPropertyGroup']['CustomProperties']:
+                
+                if isinstance(list_item, dict):
+                    for key in list_item:
+                        for item in list_item[key]:
+                            if '@name' in item:
+                                if item['@name']==  'DetectorCommercialName':
+                                    detector = item['@value']
+                                if item['@name']== 'StemSegment':
+                                    segment = '_'+item['@value']
+    return detector+segment, metadata_dict['Metadata']
+
+def adorned_to_sidpy(images):
+    """
+    Convert a list of adorned images to a dictionary of Sidpy datasets.
+    Each dataset is created from the image data and adorned metadata.       
+    The datasets are stored in a dictionary with keys 'Channel_000', 'Channel_001', etc.
+    The dimensions of the datasets are set based on the image data shape and pixel sizes.
+    The original metadata is also stored in the dataset.
+    Args:           
+        images (list or object): A list of adorned images or a single adorned image.
+        Returns:    
+        dict: A dictionary of Sidpy datasets, where each dataset corresponds to an image.
+    """
+    
+    data_sets = {}
+    if not isinstance(images, list):
+        images = [images]
+    for index, image in enumerate(images):
+        name, original_metadata = read_adorned_metadata(image)
+        data_sets[f'Channel_{index:03}'] = sidpy.Dataset.from_array(image.data.T, title=name)
+        ds = data_sets[f'Channel_{index:03}']
+        
+
+        ds.original_metadata = original_metadata
+
+        pixel_size_x_m = float(ds.original_metadata['BinaryResult']['PixelSize']['X']['#text'])
+        pixel_size_y_m = float(ds.original_metadata['BinaryResult']['PixelSize']['Y']['#text'])
+        pixel_size_x_nm = pixel_size_x_m * 1e9
+        pixel_size_y_nm = pixel_size_y_m * 1e9
+        if image.data.ndim == 3:
+            ds.data_type = 'image_stack'
+            ds.set_dimension(0, sidpy.Dimension(np.arange(image.data.shape[0]),
+                                           name='frame', units='frame', quantity='Length', dimension_type='temporal'))
+            ds.set_dimension(1, sidpy.Dimension(np.arange(image.data.shape[1]) * pixel_size_y_nm,
+                                          name='y', units='nm', quantity='Length', dimension_type='spatial'))
+            ds.set_dimension(2, sidpy.Dimension(np.arange(image.data.shape[2]) * pixel_size_x_nm,
+                                          name='x', units='nm', quantity='Length', dimension_type='spatial'))        
+        else:         
+            ds.data_type = 'image'
+            ds.set_dimension(0, sidpy.Dimension(np.arange(image.data.shape[0]) * pixel_size_y_nm,
+                                          name='y', units='nm', quantity='Length', dimension_type='spatial'))   
+            ds.set_dimension(1, sidpy.Dimension(np.arange(image.data.shape[1]) * pixel_size_x_nm,
+                                          name='x', units='nm', quantity='Length', dimension_type='spatial'))
+
+    return data_sets
+
 
 ###############################################
 # Support old pyTEM file format

{pytemlib-0.2025.2.2 → pytemlib-0.2025.4.0}/pyTEMlib/graph_tools.py

@@ -5,7 +5,6 @@ import numpy as np
 # import ase
 import sys
 
-# from scipy.spatial import cKDTree, Voronoi, ConvexHull
 import scipy.spatial
 import scipy.optimize
 import scipy.interpolate
@@ -20,7 +19,7 @@ import pyTEMlib.crystal_tools
 from tqdm.auto import tqdm, trange
 
 from .graph_viz import *
-
+QT_available = False
 
 ###########################################################################
 # utility functions
@@ -212,6 +211,14 @@ def get_voronoi(tetrahedra, atoms, bond_radii=None, optimize=True):
     """
 
     extent = atoms.cell.lengths()
+    print('extent', extent)
+
+    if np.abs(atoms.positions[:, 2]).sum() <= 0.01:
+        positions = atoms.positions[:, :2]
+        extent = extent[:2]
+    else:
+        positions = atoms.positions
+
     if atoms.info is None:
         atoms.info = {}
 
@@ -232,8 +239,8 @@ def get_voronoi(tetrahedra, atoms, bond_radii=None, optimize=True):
         r_a = []
         for vert in vertices:
             r_a.append(bond_radii[vert])
-        voronoi, radius = interstitial_sphere_center(atoms.positions[vertices], r_a, optimize=optimize)
-
+        voronoi, radius = interstitial_sphere_center(positions[vertices], r_a, optimize=optimize)
+    
         r_a = np.average(r_a)  # np.min(r_a)
         r_aa.append(r_a)
 
@@ -247,7 +254,7 @@ def get_voronoi(tetrahedra, atoms, bond_radii=None, optimize=True):
 def find_overlapping_spheres(voronoi_vertices, r_vv, r_a, cheat=1.):
     """Find overlapping spheres"""
 
-    vertex_tree = scipy.spatial.cKDTree(voronoi_vertices)
+    vertex_tree = scipy.spatial.KDTree(voronoi_vertices)
 
     pairs = vertex_tree.query_pairs(r=r_a * 2)
 
@@ -424,7 +431,7 @@ def get_non_periodic_supercell(super_cell):
     return atoms
 
 def get_connectivity_matrix(crystal, atoms, polyhedra):
-    crystal_tree = scipy.spatial.cKDTree(crystal.positions)
+    crystal_tree = scipy.spatial.KDTree(crystal.positions)
     
     
     connectivity_matrix = np.zeros([len(atoms),len(atoms)], dtype=int)
@@ -476,8 +483,8 @@ def get_bonds(crystal, shift= 0., verbose = False, cheat=1.0):
     other = []
     super_cell_atoms =[]
     
-    atoms_tree = scipy.spatial.cKDTree(atoms.positions-crystal.cell.lengths())
-    crystal_tree = scipy.spatial.cKDTree(crystal.positions)
+    atoms_tree = scipy.spatial.KDTree(atoms.positions-crystal.cell.lengths())
+    crystal_tree = scipy.spatial.KDTree(crystal.positions)
     connectivity_matrix = np.zeros([len(atoms),len(atoms)], dtype=float)
     
     for polyhedron in polyhedra.values():
@@ -699,18 +706,21 @@ def find_polyhedra(atoms, optimize=True, cheat=1.0, bond_radii=None):
         raise TypeError('This function needs an ase.Atoms object')
 
     if np.abs(atoms.positions[:, 2]).sum() <= 0.01:
-        tetrahedra = scipy.spatial.Delaunay(atoms.positions[:, :2])
+        positions = atoms.positions[:, :2]
+        print('2D')
     else:
-        tetrahedra = scipy.spatial.Delaunay(atoms.positions)
+        positions = atoms.positions
+    tetrahedra = scipy.spatial.Delaunay(positions)
 
     voronoi_vertices, voronoi_tetrahedrons, r_vv, r_a = get_voronoi(tetrahedra, atoms, optimize=optimize, bond_radii=bond_radii)
-    if np.abs(atoms.positions[:, 2]).sum() <= 0.01:
-        r_vv = np.array(r_vv)*3.
+    
+    if positions.shape[1] < 3:
+        r_vv = np.array(r_vv)*1.
     overlapping_pairs = find_overlapping_spheres(voronoi_vertices, r_vv, r_a, cheat=cheat)
 
     clusters, visited_all = find_interstitial_clusters(overlapping_pairs)
 
-    if np.abs(atoms.positions[:, 2]).sum() <= 0.01:
+    if positions.shape[1] < 3:
         rings = get_polygons(atoms, clusters, voronoi_tetrahedrons)
         return rings
     else:
@@ -770,7 +780,7 @@ def sort_polyhedra_by_vertices(polyhedra, visible=range(4, 100), z_lim=[0, 100],
 ##########################
 # New Graph Stuff
 ##########################
-def breadth_first_search(graph, initial, projected_crystal):
+def breadth_first_search2(graph, initial, projected_crystal):
     """ breadth first search of atoms viewed as a graph
 
     the projection dictionary has to contain the following items
@@ -794,15 +804,23 @@ def breadth_first_search(graph, initial, projected_crystal):
     """
 
     projection_tags = projected_crystal.info['projection']
-
-    # get lattice vectors to hopp along through graph
-    projected_unit_cell = projected_crystal.cell[:2, :2]
-    a_lattice_vector = projected_unit_cell[0]
-    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 = np.append(main, projection_tags['near_base'], axis=0)  # all nearest atoms
+    if 'lattice_vector' in projection_tags:
+        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 = []
+    else:
+        # get lattice vectors to hopp along through graph
+        projected_unit_cell = projected_crystal.cell[:2, :2]
+        a_lattice_vector = projected_unit_cell[0]
+        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
-    neighbour_tree = scipy.spatial.cKDTree(graph)
+    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) 
+
+    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)
@@ -835,6 +853,53 @@ def breadth_first_search(graph, initial, projected_crystal):
 
     return graph[visited], ideal
 
+
+
+def breadth_first_search_felxible(graph, initial, 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.  
+    """
+    if isinstance(lattice_parameter, ase.Atoms):
+        lattice_parameter = lattice_parameter.cell.lengths()[:2]
+    elif isinstance(lattice_parameter, float):
+        lattice_parameter = [lattice_parameter]
+    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)
+    visited = []  # the atoms we visited
+    angles = []  # atoms at ideal lattice
+    sub_lattice = []  # atoms in base and disregarded
+    queue = [initial]
+    queue_angles=[0]
+    
+    while queue:
+        node = queue.pop(0)
+        angle = queue_angles.pop(0)
+        if node not in visited:
+            visited.append(node)
+            angles.append(angle)
+            neighbors = indices[node]
+            for i, neighbour in enumerate(neighbors):
+                if neighbour not in visited:
+                    hopp = graph[node] - graph[neighbour]
+                    distance_to_ideal = np.linalg.norm(hopp)
+                    if np.min(np.abs(distance_to_ideal - lattice_parameter)) < tolerance:
+                        queue.append(neighbour) 
+                        queue_angles.append(np.arctan2(hopp[1], hopp[0]))
+    angles[0] = angles[1]
+    out_atoms = np.stack([graph[visited][:, 0], graph[visited][:, 1], angles])
+    return out_atoms.T, visited
+
+def delete_rim_atoms(atoms, extent, rim_distance):
+    rim = np.where(atoms[:, :2] - extent > -rim_distance)[0]
+    middle_atoms = np.delete(atoms, rim, axis=0)
+    rim = np.where(middle_atoms[:, :2].min(axis=1)<rim_distance)[0]
+    middle_atoms = np.delete(middle_atoms, rim, axis=0)
+    return middle_atoms
+
 ####################
 # Distortion Matrix
 ####################
@@ -992,7 +1057,7 @@ def get_significant_vertices(vertices, distance=3):
             list of points that are all a minimum of 3 apart.
     """
 
-    tt = scipy.spatial.cKDTree(np.array(vertices))
+    tt = scipy.spatial.KDTree(np.array(vertices))
     near = tt.query_ball_point(vertices, distance)
     ideal_vertices = []
     for indices in near:
@@ -1146,21 +1211,16 @@ def undistort_stack(distortion_matrix, data):
     nimages = data.shape[0]
     done = 0
 
-    if QT_available:
-        progress = ft.ProgressDialog("Correct Scan Distortions", nimages)
+    
     for i in range(nimages):
-        if QT_available:
-            progress.set_value(i)
-        elif done < int((i + 1) / nimages * 50):
-            done = int((i + 1) / nimages * 50)
-            sys.stdout.write('\r')
-            # progress output :
-            sys.stdout.write("[%-50s] %d%%" % ('=' * done, 2 * done))
-            sys.stdout.flush()
+        done = int((i + 1) / nimages * 50)
+        sys.stdout.write('\r')
+        # progress output :
+        sys.stdout.write("[%-50s] %d%%" % ('=' * done, 2 * done))
+        sys.stdout.flush()
 
         interpolated[i, :, :] = griddata(corrected, intensity_values[i, :], (grid_x, grid_y), method='linear')
-    if QT_available:
-        progress.set_value(nimages)
+    
     print(':-)')
     print('You have successfully completed undistortion of image stack')
     return interpolated