pyTEMlib 0.2025.2.2__py3-none-any.whl → 0.2025.4.0__py3-none-any.whl

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/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/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/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/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/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

pyTEMlib/image_tools.py

@@ -182,24 +182,21 @@ def fourier_transform(dset: sidpy.Dataset) -> sidpy.Dataset:
     assert isinstance(dset, sidpy.Dataset), 'Expected a sidpy Dataset'
 
     selection = []
-    image_dim = []
-    # image_dim = get_image_dims(sidpy.DimensionTypes.SPATIAL)
-
+    image_dims = pyTEMlib.sidpy_tools.get_image_dims(dset)
     if dset.data_type == sidpy.DataType.IMAGE_STACK:
-        image_dim = dset.get_image_dims()
         stack_dim = dset.get_dimensions_by_type('TEMPORAL')
 
-        if len(image_dim) != 2:
+        if len(image_dims) != 2:
             raise ValueError('need at least two SPATIAL dimension for an image stack')
 
         for i in range(dset.ndim):
-            if i in image_dim:
+            if i in image_dims:
                 selection.append(slice(None))
             if len(stack_dim) == 0:
-                stack_dim = i
+                stack_dims = i
                 selection.append(slice(None))
             elif i in stack_dim:
-                stack_dim = i
+                stack_dims = i
                 selection.append(slice(None))
             else:
                 selection.append(slice(0, 1))
@@ -212,6 +209,7 @@ def fourier_transform(dset: sidpy.Dataset) -> sidpy.Dataset:
         return
 
     new_image = new_image - new_image.min()
+    
     fft_transform = (np.fft.fftshift(np.fft.fft2(new_image)))
 
     image_dims = pyTEMlib.sidpy_tools.get_image_dims(dset)
@@ -227,12 +225,11 @@ def fourier_transform(dset: sidpy.Dataset) -> sidpy.Dataset:
     fft_dset.modality = 'fft'
 
     fft_dset.set_dimension(0, sidpy.Dimension(np.fft.fftshift(np.fft.fftfreq(new_image.shape[0],
-                                                                             d=ft.get_slope(dset.x.values))),
-
+                                                                             d=dset.x[1]-dset.x[0])),
                                               name='u', units=units_x, dimension_type='RECIPROCAL',
                                               quantity='reciprocal_length'))
     fft_dset.set_dimension(1, sidpy.Dimension(np.fft.fftshift(np.fft.fftfreq(new_image.shape[1],
-                                                                             d=ft.get_slope(dset.y.values))),
+                                                                             d=dset.y[1]- dset.y[0])),
                                               name='v', units=units_y, dimension_type='RECIPROCAL',
                                               quantity='reciprocal_length'))
 
@@ -319,7 +316,9 @@ def diffractogram_spots(dset, spot_threshold, return_center=True, eps=0.1):
     print(f'Found {spots_random.shape[0]} reflections')
 
     # Needed for conversion from pixel to Reciprocal space
-    rec_scale = np.array([ft.get_slope(dset.u.values), ft.get_slope(dset.v.values)])
+    image_dims = dset.get_image_dims(return_axis=True)
+    rec_scale = np.array([image_dims[0].slope, image_dims[1].slope])
+    
     spots_random[:, :2] = spots_random[:, :2]*rec_scale+[dset.u.values[0], dset.v.values[0]]
     # sort reflections
     spots_random[:, 2] = np.linalg.norm(spots_random[:, 0:2], axis=1)
@@ -516,7 +515,8 @@ def complete_registration(main_dataset, storage_channel=None):
 
     rigid_registered_dataset = rigid_registration(main_dataset)
 
-    
+    print(rigid_registered_dataset)
+    rigid_registered_dataset.data_type = 'IMAGE_STACK'
     print('Non-Rigid_Registration')
 
     non_rigid_registered = demon_registration(rigid_registered_dataset)
@@ -580,7 +580,6 @@ def demon_registration(dataset, verbose=False):
     resampler.SetDefaultPixelValue(0)
 
     for i in trange(nimages):
-
         moving = sitk.GetImageFromArray(dataset[i])
         moving_f = sitk.DiscreteGaussian(moving, 2.0)
         displacement_field = demons.Execute(fixed, moving_f)
@@ -596,20 +595,21 @@ def demon_registration(dataset, verbose=False):
     demon_registered.title = 'Non-Rigid Registration'
     demon_registered.source = dataset.title
 
-    demon_registered.metadata = {'analysis': 'non-rigid demon registration'}
-    demon_registered.metadata['experiment'] = dataset.metadata['experiment'].copy()
-    if 'input_crop' in dataset.metadata:
-        demon_registered.metadata['input_crop'] = dataset.metadata['input_crop']
-    if 'input_shape' in dataset.metadata:
-        demon_registered.metadata['input_shape'] = dataset.metadata['input_shape']
-    demon_registered.metadata['input_dataset'] = dataset.source
+    demon_registered.metadata =dataset.metadata.copy()
+    if 'analysis' not in demon_registered.metadata:
+        demon_registered.metadata['analysis'] = {}
+    demon_registered.metadata['analysis']['non_rigid_demon_registration'] = {'package': 'simpleITK',
+                                                                             'method': 'DiscreteGaussian',
+                                                                             'variance': 2,
+                                                                             'input_dataset': dataset.source}
+    demon_registered.data_type = 'IMAGE_STACK'
     return demon_registered
 
 
 ###############################
 # Rigid Registration New 05/09/2020
 
-def rigid_registration(dataset, sub_pixel=True):
+def rigid_registration(dataset, normalization=None):
     """
     Rigid registration of image stack with pixel accuracy
 
@@ -631,51 +631,32 @@ def rigid_registration(dataset, sub_pixel=True):
         raise TypeError('We need a sidpy.Dataset')
     if dataset.data_type.name != 'IMAGE_STACK':
         raise TypeError('Registration makes only sense for an image stack')
-    
-    frame_dim = []
-    spatial_dim = []
-    selection = []
-    
-    for i, axis in dataset._axes.items():
-        if axis.dimension_type.name == 'SPATIAL':
-            spatial_dim.append(i)
-            selection.append(slice(None))
-        else:
-            frame_dim.append(i)
-            selection.append(slice(0, 1))
-    
-    if len(spatial_dim) != 2:
-        print('need two spatial dimensions')
-    if len(frame_dim) != 1:
-        print('need one frame dimensions')
-    
-    nopix = dataset.shape[spatial_dim[0]]
-    nopiy = dataset.shape[spatial_dim[1]]
-    nimages = dataset.shape[frame_dim[0]]
-    
-    print('Stack contains ', nimages, ' images, each with', nopix, ' pixels in x-direction and ', nopiy,
-          ' pixels in y-direction')
-    
-    fixed = dataset[tuple(selection)].squeeze().compute()
-    fft_fixed = np.fft.fft2(fixed)
+
+    if isinstance (normalization, str):
+        if normalization.lower() != 'phase':
+            nomralization = None
+    else:
+        normalization = None
+
+    if dataset.get_dimensions_by_type('TEMPORAL')[0] != 0:
+        raise TypeError('Image stack does not have correct frame dimension')
+        
+    stack_dim = dataset.get_dimensions_by_type('TEMPORAL', return_axis=True)[0]
+    image_dim = dataset.get_image_dims(return_axis=True)
+    if len(image_dim) != 2:
+        raise ValueError('need at least two SPATIAL dimension for an image stack')
     
     relative_drift = [[0., 0.]]
-    
-    for i in trange(nimages):
-        selection[frame_dim[0]] = slice(i, i+1)
-        moving = dataset[tuple(selection)].squeeze().compute()
-        fft_moving = np.fft.fft2(moving)
-        if sub_pixel:
-            shift = skimage.registration.phase_cross_correlation(fft_fixed, fft_moving, upsample_factor=1000,
-                                                                 space='fourier')[0]
-        else:    
-            image_product = fft_fixed * fft_moving.conj()
-            cc_image = np.fft.fftshift(np.fft.ifft2(image_product))
-            shift = np.array(ndimage.maximum_position(cc_image.real))-cc_image.shape[0]/2
-        fft_fixed = fft_moving
-        relative_drift.append(shift)
-    rig_reg, drift = rig_reg_drift(dataset, relative_drift)
-    crop_reg, input_crop = crop_image_stack(rig_reg, drift)
+    im1 = np.fft.fft2(np.array(dataset[0]))
+    for i in range(1, len(stack_dim)):
+        im2 = np.fft.fft2(np.array(dataset[i]))
+        shift, error, _ = skimage.registration.phase_cross_correlation(im1, im2, normalization=normalization, space='fourier')
+        print(shift)
+        im1 = im2.copy()
+        relative_drift.append(shift)    
+        
+    rig_reg, drift = pyTEMlib.image_tools.rig_reg_drift(dataset, relative_drift)
+    crop_reg, input_crop = pyTEMlib.image_tools.crop_image_stack(rig_reg, drift)
     
     rigid_registered = sidpy.Dataset.from_array(crop_reg, 
                                                 title='Rigid Registration', 
@@ -684,21 +665,22 @@ def rigid_registration(dataset, sub_pixel=True):
                                                 units=dataset.units)
     rigid_registered.title = 'Rigid_Registration'
     rigid_registered.source = dataset.title
-    rigid_registered.metadata = {'analysis': 'rigid sub-pixel registration', 'drift': drift,
-                                 'input_crop': input_crop, 'input_shape': dataset.shape[1:]}
+    rigid_registered.metadata['analysis'] = {'rigid_registration': {'drift': drift,
+                                 'input_crop': input_crop, 'input_shape': dataset.shape[1:]}}
     rigid_registered.metadata['experiment'] = dataset.metadata['experiment'].copy()
     rigid_registered.set_dimension(0, sidpy.Dimension(np.arange(rigid_registered.shape[0]), 
                                           name='frame', units='frame', quantity='time',
                                           dimension_type='temporal'))
     
-    array_x = dataset._axes[spatial_dim[0]][input_crop[0]:input_crop[1]].values
-    rigid_registered.set_dimension(1, sidpy.Dimension(array_x,
-                                          'x', units='nm', quantity='Length',
-                                          dimension_type='spatial'))
-    array_y = dataset._axes[spatial_dim[1]][input_crop[2]:input_crop[3]].values
-    rigid_registered.set_dimension(2, sidpy.Dimension(array_y,
-                                          'y', units='nm', quantity='Length',
-                                          dimension_type='spatial'))
+    array_x = image_dim[0].values[input_crop[0]:input_crop[1]]
+    rigid_registered.set_dimension(1, sidpy.Dimension(array_x, name='x',
+                                                      units='nm', quantity='Length',
+                                                      dimension_type='spatial'))
+    array_y =image_dim[1].values[input_crop[2]:input_crop[3]]
+    rigid_registered.set_dimension(2, sidpy.Dimension(array_y, name='y',
+                                                      units='nm', quantity='Length',
+                                                      dimension_type='spatial'))
+    rigid_registered.data_type = 'IMAGE_STACK'
     return rigid_registered.rechunk({0: 'auto', 1: -1, 2: -1})
 
 
@@ -773,13 +755,12 @@ def crop_image_stack(rig_reg, drift):
     -------
     numpy array
     """
+    xpmax = int(rig_reg.shape[1] - -np.floor(np.min(np.array(drift)[:, 0])))
+    xpmin = int(np.ceil(np.max(np.array(drift)[:, 0])))
+    ypmax = int(rig_reg.shape[1] - -np.floor(np.min(np.array(drift)[:, 1])))
+    ypmin = int(np.ceil(np.max(np.array(drift)[:, 1])))
 
-    xpmin = int(-np.floor(np.min(np.array(drift)[:, 0])))
-    xpmax = int(rig_reg.shape[1] - np.ceil(np.max(np.array(drift)[:, 0])))
-    ypmin = int(-np.floor(np.min(np.array(drift)[:, 1])))
-    ypmax = int(rig_reg.shape[2] - np.ceil(np.max(np.array(drift)[:, 1])))
-
-    return rig_reg[:, xpmin:xpmax, ypmin:ypmax], [xpmin, xpmax, ypmin, ypmax]
+    return rig_reg[:, xpmin:xpmax, ypmin:ypmax:], [xpmin, xpmax, ypmin, ypmax]
 
 
 class ImageWithLineProfile:
@@ -902,9 +883,9 @@ def get_profile(dataset, line, spline_order=-1):
     """
     xv, yv = get_line_selection_points(line)
     if dataset.data_type.name == 'IMAGE':
-        dataset.get_image_dims()
-        xv /= (dataset.x[1] - dataset.x[0])
-        yv /= (dataset.y[1] - dataset.y[0])
+        image_dims = dataset.get_image_dims(return_axis=True)
+        xv /= image_dims[0].slope
+        yv /= image_dims[1].slope
         profile = scipy.ndimage.map_coordinates(np.array(dataset), [xv, yv])
         
         profile_dataset = sidpy.Dataset.from_array(profile.sum(axis=0))
@@ -1101,7 +1082,7 @@ def clean_svd(im, pixel_size=1, source_size=5):
     patch_size = int(source_size/pixel_size)
     if patch_size < 3:
         patch_size = 3
-    patches = image.extract_patches_2d(im, (patch_size, patch_size))
+    patches = image.extract_patches_2d(np.array(im), (patch_size, patch_size))
     patches = patches.reshape(patches.shape[0], patches.shape[1]*patches.shape[2])
 
     num_components = 32
@@ -1110,6 +1091,8 @@ def clean_svd(im, pixel_size=1, source_size=5):
     u_im_size = int(np.sqrt(u.shape[0]))
     reduced_image = u[:, 0].reshape(u_im_size, u_im_size)
     reduced_image = reduced_image/reduced_image.sum()*im.sum()
+    if isinstance(im, sidpy.Dataset):
+        reduced_image = im.like_data(reduced_image)
     return reduced_image
 
 
@@ -1402,11 +1385,16 @@ def decon_lr(o_image, probe,  verbose=False):
     error = np.ones(o_image.shape, dtype=np.complex64)
     est = np.ones(o_image.shape, dtype=np.complex64)
     source = np.ones(o_image.shape, dtype=np.complex64)
+    o_image = o_image - o_image.min()
+    image_mult = o_image.max()
+    o_image = o_image / o_image.max()
     source.real = o_image
 
     response_ft = fftpack.fft2(probe_c)
 
-    ap_angle = o_image.metadata['experiment']['convergence_angle'] / 1000.0  # now in rad
+    ap_angle = o_image.metadata['experiment']['convergence_angle']
+    if ap_angle > .1:
+        ap_angle /= 1000  # now in rad
 
     e0 = float(o_image.metadata['experiment']['acceleration_voltage'])
 
@@ -1444,13 +1432,10 @@ def decon_lr(o_image, probe,  verbose=False):
         est_old = est.copy()
         error = source / np.real(fftpack.fftshift(fftpack.ifft2(fftpack.fft2(est) * response_ft)))
         est = est * np.real(fftpack.fftshift(fftpack.ifft2(fftpack.fft2(error) * np.conjugate(response_ft))))
-        # est = est_old * est
-        # est =  np.real(fftpack.fftshift(fftpack.ifft2(fftpack.fft2(est)*fftpack.fftshift(aperture) )))
-
+        
         error_new = np.real(np.sum(np.power(error, 2))) - error_old
         dest = np.sum(np.power((est - est_old).real, 2)) / np.sum(est) * 100
-        # print(np.sum((est.real - est_old.real)* (est.real - est_old.real) )/np.sum(est.real)*100 )
-
+        
         if error_old != 0:
             de = error_new / error_old * 1.0
         else:
@@ -1466,10 +1451,10 @@ def decon_lr(o_image, probe,  verbose=False):
             print('terminate')
         progress.update(1)
     progress.write(f"converged in {i} iterations")
-    # progress.close()
     print('\n Lucy-Richardson deconvolution converged in ' + str(i) + '  iterations')
-    est2 = np.real(fftpack.ifft2(fftpack.fft2(est) * fftpack.fftshift(aperture)))
+    est2 = np.real(fftpack.ifft2(fftpack.fft2(est) * fftpack.fftshift(aperture)))*image_mult
     out_dataset = o_image.like_data(est2)
     out_dataset.title = 'Lucy Richardson deconvolution'
     out_dataset.data_type = 'image'
     return out_dataset
+

pyTEMlib/probe_tools.py

@@ -107,6 +107,7 @@ def get_chi(ab, size_x, size_y, verbose=False):
     return chi, aperture
 
 
+
 def print_aberrations(ab):
     from IPython.display import HTML, display
     output = '<html><body>'
@@ -133,6 +134,203 @@ def print_aberrations(ab):
     display(HTML(output))
 
 
+
+def print_aberrations_polar(ab):
+    from IPython.display import HTML, display
+    
+    ab['C12_r'], ab['C12_phi'] = cart2pol(ab['C12a'], ab['C12b'])
+    ab['C21_r'], ab['C21_phi'] = cart2pol(ab['C21a'], ab['C21b'])
+    ab['C23_r'], ab['C23_phi'] = cart2pol(ab['C23a'], ab['C23b'])
+    ab['C32_r'], ab['C32_phi'] = cart2pol(ab['C32a'], ab['C32b'])
+    ab['C34_r'], ab['C34_phi'] = cart2pol(ab['C34a'], ab['C34b'])
+    ab['C41_r'], ab['C41_phi'] = cart2pol(ab['C41a'], ab['C41b'])
+    ab['C43_r'], ab['C43_phi'] = cart2pol(ab['C43a'], ab['C43b'])
+    ab['C45_r'], ab['C45_phi'] = cart2pol(ab['C45a'], ab['C45b'])
+    ab['C52_r'], ab['C52_phi'] = cart2pol(ab['C52a'], ab['C52b'])
+    ab['C54_r'], ab['C54_phi'] = cart2pol(ab['C54a'], ab['C54b'])
+    ab['C56_r'], ab['C56_phi'] = cart2pol(ab['C56a'], ab['C56b'])
+    
+    output = '<html><body>'
+    output += f"Aberrations [nm] for acceleration voltage: {ab['acceleration_voltage'] / 1e3:.0f} kV"
+    output += '<table>'
+    output += f"<tr><td> C10 </td><td> {ab['C10']:.1f} </tr>"
+    output += f"<tr><td> C12(A1): r </td><td> {ab['C12_r']:20.1f} <td> φ  </td><td> {ab['C12_phi']:20.1f} </tr>"
+    output += f"<tr><td> C21a (B2): r</td><td> {ab['C21_r']:20.1f} <td> φ </td><td> {ab['C21_phi']:20.1f} "
+    output += f"    <td> C23a (A2) </td><td> {ab['C23_r']:20.1f} <td> φ  </td><td> {ab['C23_phi']:20.1f} </tr>"
+    output += f"<tr><td> C30 </td><td> {ab['C30']:.1f} </tr>"
+    output += f"<tr><td> C32 (S3) </td><td> {ab['C32_r']:20.1f} <td> φ </td><td> {ab['C32_phi']:20.1f} "
+    output += f"<td> C34a (A3) </td><td> {ab['C34a']:20.1f} <td> φ  </td><td> {ab['C34_phi']:20.1f} </tr>"
+    output += f"<tr><td> C41 (B4) </td><td> {ab['C41_r']:.3g} <td> φ  </td><td> {ab['C41_phi']:20.1f} "
+    output += f"    <td> C43 (D4) </td><td> {ab['C43_r']:.3g} <td> φ (D4) </td><td> {ab['C43_phi']:20.1f} "
+    output += f"    <td> C45 (A4) </td><td> {ab['C45_r']:.3g} <td> φ (A4)</td><td> {ab['C45_phi']:20.1f} </tr>"
+    output += f"<tr><td> C50 </td><td> {ab['C50']:.3g} </tr>"
+    output += f"<tr><td> C52 </td><td> {ab['C52a']:.3g} <td> φ </td><td> {ab['C52_phi']:20.1f} "
+    output += f"<td> C54 </td><td> {ab['C54_r']:.3g} <td> C54 φ </td><td> {ab['C54_phi']:.1f} "
+    output += f"<td> C56 </td><td> {ab['C56_r']:.3g} <td> C56  </td><td> {ab['C56_phi']:.1f} </tr>"
+    output += f"<tr><td> Cc </td><td> {ab['Cc']:.3g} </tr>"
+
+    output += '</table></body></html>'
+
+    display(HTML(output))
+
+
+def pol2cart(rho, theta):
+    x = rho * np.cos(theta)
+    y = rho * np.sin(theta)
+    return x, y
+
+def ceos_to_nion(ab):
+    aberrations = {'C10': 0, 'C12a': 0, 'C12b': 0, 'C21a': 0, 'C21b': 0, 'C23a': 0, 'C23b': 0, 'C30': 0.,
+                   'C32a': 0., 'C32b': -0., 'C34a': 0., 'C34b': 0., 'C41a': 0., 'C41b': -0., 'C43a': 0.,
+                   'C43b': -0., 'C45a': -0., 'C45b': -0., 'C50': 0., 'C52a': -0., 'C52b': 0.,
+                   'C54a': -0., 'C54b': -0., 'C56a': -0., 'C56b': 0., 'C70': 0.}
+    aberrations['acceleration_voltage'] = 200000
+    for key in ab.keys():
+        if key == 'C1':
+            aberrations['C10'] = ab['C10']
+        elif key == 'A1-a':
+            x, y = pol2cart(ab['A1-a'], ab['A1-p'])
+            aberrations['C12a'] = x
+            aberrations['C12b'] = y
+        elif key == 'B2-a':
+            x, y = pol2cart(ab['B2-a'], ab['B2-p'])
+            aberrations['C21a'] = 3 * x
+            aberrations['C21b'] = 3 * y
+        elif key == 'A2-a':
+            x, y = pol2cart(ab['A2-a'], ab['A2-p'])
+            aberrations['C23a'] = x
+            aberrations['C23b'] = y
+        elif key == 'C3':
+            aberrations['C30'] = ab['C3']
+        elif key == 'S3-a':
+            x, y = pol2cart(ab['S3-a'], ab['S3-p'])
+            aberrations['C32a'] = 4 * x
+            aberrations['C32b'] = 4 * y
+        elif key == 'A3-a':
+            x, y = pol2cart(ab['A3-a'], ab['A3-p'])
+            aberrations['C34a'] = x
+            aberrations['C34b'] = y
+        elif key == 'B4-a':
+            x, y = pol2cart(ab['B4-a'], ab['B4-p'])
+            aberrations['C41a'] = 4 * x
+            aberrations['C41b'] = 4 * y
+        elif key == 'D4-a':
+            x, y = pol2cart(ab['D4-a'], ab['D4-p'])
+            aberrations['C43a'] = 4 * x
+            aberrations['C43b'] = 4 * y
+        elif key == 'A4-a':
+            x, y = pol2cart(ab['A4-a'], ab['A4-p'])
+            aberrations['C45a'] = x
+            aberrations['C45b'] = y
+        elif key == 'C5':
+            aberrations['C50'] = ab['C5']
+        elif key == 'A5-a':
+            x, y = pol2cart(ab['A5-a'], ab['A5-p'])
+            aberrations['C56a'] = x
+            aberrations['C56b'] = y
+    return aberrations
+
+def ceos_carth_to_nion(ab):
+    aberrations = {'C10': 0, 'C12a': 0, 'C12b': 0, 'C21a': 0, 'C21b': 0, 'C23a': 0, 'C23b': 0, 'C30': 0.,
+                   'C32a': 0., 'C32b': -0., 'C34a': 0., 'C34b': 0., 'C41a': 0., 'C41b': -0., 'C43a': 0.,
+                   'C43b': -0., 'C45a': -0., 'C45b': -0., 'C50': 0., 'C52a': -0., 'C52b': 0.,
+                   'C54a': -0., 'C54b': -0., 'C56a': -0., 'C56b': 0., 'C70': 0.}
+    aberrations['acceleration_voltage'] = 200000
+    for key in ab.keys():
+        if key == 'C1':
+            aberrations['C10'] = ab['C1'][0]*1e9
+        elif key == 'A1':
+            aberrations['C12a'] = ab['A1'][0]*1e9
+            aberrations['C12b'] = ab['A1'][1]*1e9
+        elif key == 'B2':
+            print('B2', ab['B2'])
+            aberrations['C21a'] = 3 * ab['B2'][0]*1e9
+            aberrations['C21b'] = 3 * ab['B2'][1]*1e9
+        elif key == 'A2':
+            aberrations['C23a'] = ab['A2'][0]*1e9
+            aberrations['C23b'] = ab['A2'][1]*1e9
+        elif key == 'C3':
+            aberrations['C30'] = ab['C3'][0]*1e9
+        elif key == 'S3':
+            aberrations['C32a'] = 4 * ab['S3'][0]*1e9
+            aberrations['C32b'] = 4 * ab['S3'][1]*1e9
+        elif key == 'A3':
+            aberrations['C34a'] = ab['A3'][0]*1e9
+            aberrations['C34b'] = ab['A3'][1]*1e9
+        elif key == 'B4':
+            aberrations['C41a'] = 4 * ab['B4'][0]*1e9
+            aberrations['C41b'] = 4 * ab['B4'][1]*1e9
+        elif key == 'D4':
+            aberrations['C43a'] = 4 * ab['D4'][0]*1e9
+            aberrations['C43b'] = 4 * ab['D4'][1]*1e9
+        elif key == 'A4':
+            aberrations['C45a'] = ab['A4'][0]*1e9
+            aberrations['C45b'] = ab['A4'][1]*1e9
+        elif key == 'C5':
+            aberrations['C50'] = ab['C5'][0]*1e9
+        elif key == 'A5':
+            aberrations['C56a'] = ab['A5'][0]*1e9
+            aberrations['C56b'] = ab['A5'][1]*1e9
+
+        
+    return aberrations
+
+def cart2pol(x, y):
+    theta = np.arctan2(y, x)
+    rho = np.hypot(x, y)
+    return theta, rho
+
+def nion_to_ceos(ab):
+    aberrations = {'C1': 0, 'A1-a': 0, 'A1-b': 0, 'B2-a': 0, 'B2-p': 0, 'A2-a': 0, 'A2-p': 0, 'C3': 0.,
+                   'S3-a': 0., 'S3-p': -0., 'A3-a': 0., 'A3-p': 0., 'B4-a': 0., 'B4-p': -0., 'D4-a': 0.,
+                   'D4-p': -0., 'A4-s': -0., 'A4-p': -0., 'C5': 0., 'A5-a': -0., 'A5-p': 0.}
+    aberrations['acceleration_voltage'] = 200000
+    for key in ab.keys():
+        if key == 'C10':
+            aberrations['C1'] = ab['C10']
+        elif key == 'C12a':
+            r, p = cart2pol(ab['C12a'], ab['C12b'])
+            aberrations['A1-a'] = r
+            aberrations['A1-p'] = p
+        elif key == 'C21a':
+            r, p = cart2pol(ab['C21a'], ab['C21b'])
+            aberrations['B2-a'] = r/3
+            aberrations['B2-p'] = p
+        elif key == 'C23a':
+            r, p = cart2pol(ab['C23a'], ab['C23b'])
+            aberrations['A2-a'] = r
+            aberrations['A2-p'] = p
+        elif key == 'C30':
+            aberrations['C3'] = ab['C30']
+        elif key == 'C32a':
+            r, p = cart2pol(ab['C32a'], ab['C32b'])
+            aberrations['S3-a'] = r/4
+            aberrations['S3-p'] = p
+        elif key == 'C34a':
+            r, p = cart2pol(ab['C34a'], ab['C34b'])
+            aberrations['A3-a'] = r
+            aberrations['A3-p'] = p
+        elif key == 'C41a':
+            r, p = cart2pol(ab['C41a'], ab['C41b'])
+            aberrations['B4-a'] = r/4
+            aberrations['B4-p'] = p
+        elif key == 'C43a':
+            r, p = cart2pol(ab['C43a'], ab['C43b'])
+            aberrations['D4-a'] = r/4
+            aberrations['D4-p'] = p
+        elif key == 'C31a':
+            r, p = cart2pol(ab['C41a'], ab['C41b'])
+            aberrations['A4-a'] = r
+            aberrations['A4-p'] = p
+        elif key == 'C50':
+            aberrations['C5'] = ab['C50']
+        elif key == 'C56a':
+            r, p = cart2pol(ab['C56a'], ab['C56b'])
+            aberrations['A5-a'] = r
+            aberrations['A5-p'] = p
+
+    return aberrations
+
 def get_ronchigram(size, ab, scale='mrad'):
     """ Get Ronchigram
 
@@ -447,15 +645,13 @@ def get_target_aberrations(TEM_name, acceleration_voltage):
               'C30': 123,
               'C32a': 95.3047364258614, 'C32b': -189.72105710231244, 'C34a': -47.45099594807912, 'C34b': -94.67424667529909,
               'C41a': -905.31842572806, 'C41b': 981.316128853203, 'C43a': 4021.8433526960034, 'C43b': 131.72716642732158, 
-              'C45a': -4702.390968272048,  'C45b': -208.25028574642903, 'C50': -663.1, 
-              'C50': 552000., 'C52a': -0., 'C52b': 0.,
+              'C45a': -4702.390968272048,  'C45b': -208.25028574642903, 'C50': 552000., 'C52a': -0., 'C52b': 0.,
               'C54a': -0., 'C54b': -0., 'C56a': -36663.643489934424, 'C56b': 21356.079837905396,
               'acceleration_voltage': 200000,
               'FOV': 34.241659495148205,
               'Cc': 1* 1e6,
               'convergence_angle': 30,
               'wavelength': 0.0025079340450548005}
- 
     return ab
 
 
@@ -488,7 +684,7 @@ def get_ronchigram_2(size, ab, scale='mrad', threshold=3):
     aperture[mask] = 0.
 
     v_noise = np.random.rand(size_x, size_y)
-    smoothing = 5
+    smoothing = 10
     phi_r = ndimage.gaussian_filter(v_noise, sigma=(smoothing, smoothing), order=0)
 
     sigma = 6  # 6 for carbon and thin

pyTEMlib/version.py

@@ -1,6 +1,6 @@
 """
 version
 """
-_version = '0.2025.02.2'
+_version = '0.2025.04.0'
 __version__ = _version
-_time = '2025-02-25 19:58:26'
+_time = '2025-04-25 19:58:26'

{pytemlib-0.2025.2.2.dist-info → pytemlib-0.2025.4.0.dist-info}/METADATA

@@ -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.dist-info → pytemlib-0.2025.4.0.dist-info}/RECORD

@@ -1,22 +1,22 @@
 pyTEMlib/__init__.py,sha256=nEN93amIEoZxO7rJgN71ABeCoXrnmaywBbE97l5lPio,178
 pyTEMlib/animation.py,sha256=G9ykYo6yB5jexjKienShO9C2b8xEXKbf7t47apwcwTw,25188
-pyTEMlib/atom_tools.py,sha256=uoyZOs0lZKyBwGH6onKSAKzA6IxseqHpgw7ZTos9Nd0,7335
+pyTEMlib/atom_tools.py,sha256=iXJbK66k3HbTNOGSWRLeUV01JlggUo1Qq89HJqbSv54,7341
 pyTEMlib/config_dir.py,sha256=4evlo9P2Yht-AnqaLI-WweLjDQcislbAP3I7P7EZsPU,2085
-pyTEMlib/core_loss_widget.py,sha256=EbCn2imCjzeLAL2h9n87APHPou1G4vvN-kA4_RQs_OE,30991
+pyTEMlib/core_loss_widget.py,sha256=XQk071ZHMGYOM6RTSIaXQlZtnFQjUyxTWbQ2ZXOFMfU,30901
 pyTEMlib/crystal_tools.py,sha256=g4OXyvd5NLw7vaXhjDP3P6VZpVV6eiyuPn8MdgR2amI,61652
 pyTEMlib/diffraction_plot.py,sha256=pM5d3bdBGa8LlPZ5lw8sLT94mlYTXELxPLv-jUP2FWY,27959
 pyTEMlib/dynamic_scattering.py,sha256=O9MxnxfndWJ2VhQRjksKNQ4yY7y-gN_hitRQ4Qox4ns,9472
 pyTEMlib/eds_tools.py,sha256=Ilof2Cars-1ILXx5g2RsU2G4BgrPwjOHgQ7-OabmbrU,28000
-pyTEMlib/eels_dialog.py,sha256=NmPjO1SVjxzah2cCEK0bR1AqwX7Dl6xwejTZkruqIUA,32619
+pyTEMlib/eels_dialog.py,sha256=QG_PU3uuzus_3I3zjfaxb2a9iYq8B053zYw-B52JklM,32595
 pyTEMlib/eels_dialog_utilities.py,sha256=73W9jFbPx-eeLEiSaBptTgGLr40bIYYfSyzLnZbhfvo,51761
-pyTEMlib/eels_tools.py,sha256=7gfDmu-CqfatVmtCPYwObJZsP5RMDx3bmFXclZzJINE,88739
-pyTEMlib/file_tools.py,sha256=gdP42-99Pjnl0tri50x8QXc33ye-1bs6Yiof3JKVn7I,59969
+pyTEMlib/eels_tools.py,sha256=pl75ZDQHz1JngxD84T_595Kfrl5TEJSETPGgkXfBtrA,88688
+pyTEMlib/file_tools.py,sha256=AIeWD3JaB1OI32_pj_RSqQuRGjPM-wiD0zTbL5W17Tc,64559
 pyTEMlib/file_tools_qt.py,sha256=tLZACS4JyGH_AOzNR_SGAhjA01y4VJB261opPhGMlm8,7223
-pyTEMlib/graph_tools.py,sha256=iu0Y2hIPU6CkQHQEh-dI1vKnUHnSNXx4-CXs2M-1Sr8,44097
+pyTEMlib/graph_tools.py,sha256=VWuTgFGeu4gn4cfRgf-76kO6u2B1ZV_dz6gLfx2k4NY,46570
 pyTEMlib/graph_viz.py,sha256=m5PwSn6l2r0bsaLWBDSHc9IGR3_PneG2BrZgnEdi07I,13644
 pyTEMlib/image_dialog.py,sha256=F-ZgKq7UnMtPPd1b9eqb7t8MXDfWN-8hVKwB2Il0x28,6235
 pyTEMlib/image_dlg.py,sha256=n5gradDiYOFGEQ3k_Wlk9RUYYzl4bl_hKLzNVcYteNE,5694
-pyTEMlib/image_tools.py,sha256=guHd29VLo2z0KXz1-XxcHYWqOiHGoKZ0A9SE_FdSO2g,52655
+pyTEMlib/image_tools.py,sha256=iBVsAr6-oQY6y2LTSbUIz6nMeAIOsSX5zPBezekJsFg,52334
 pyTEMlib/info_widget.py,sha256=lkzQOuNVlkaasiZDtc5UtYk541-plYNfnW4DQwQB_iA,53467
 pyTEMlib/info_widget3.py,sha256=QSbdSj6m57KQTir2fNhulVgjOu9EQL31c-9SzTlghnE,55495
 pyTEMlib/interactive_image.py,sha256=5PwypcA1OjLAD-fi8bmWWFHuOjdIPVY9Dh59V24WuDA,34
@@ -25,14 +25,14 @@ pyTEMlib/low_loss_widget.py,sha256=0SxHOAuUnuNjDrJSNS2PeWD6hjyuB5FCYxmVfsDTq5c,2
 pyTEMlib/microscope.py,sha256=iigUF1UImHEfmL2wqEBBj3aNRgEYouDbIln8VCo4_KM,1545
 pyTEMlib/peak_dialog.py,sha256=r3mhYvECC9niFFItS1oGa96F2nFthsE5kfpA3yVXQaE,51872
 pyTEMlib/peak_dlg.py,sha256=qcjcnhwpGa4jBCeXzwQz9sCyX-tHsLLQ67ToqfKOiQY,11550
-pyTEMlib/probe_tools.py,sha256=xVwoThZSSOY6hjUMO53va9R_qI7SL5dfwIigz6sd3DI,29242
+pyTEMlib/probe_tools.py,sha256=sDW9CW3SMwjvSHYcEufceismHv_LVkqxcS-gCtEklCg,37926
 pyTEMlib/sidpy_tools.py,sha256=0oIx-qMtEmcZmLazQKW19dd-KoxyY3B15aIeMcyHA8E,4878
 pyTEMlib/simulation_tools.py,sha256=RmegD5TpQMU68uASvzZWVplAqs7bM5KkF6bWDWLjyc0,2799
-pyTEMlib/version.py,sha256=6GC1KyGj1D_9Hs8_3OJrq7lHdhziwk9qllcxLoWcEns,94
+pyTEMlib/version.py,sha256=znL_4Pt7sBR4l1I39FM04SGxnneUfbZrv9R_6tFaynA,94
 pyTEMlib/xrpa_x_sections.py,sha256=m4gaH7gaJiNi-CsIT9aKoH4fB6MQIAe876kxEmzSebI,1825392
-pytemlib-0.2025.2.2.dist-info/LICENSE,sha256=7HdBF6SXIBd38bHOKkQd4DYR1KV-OYm9mwB16fM-984,1062
-pytemlib-0.2025.2.2.dist-info/METADATA,sha256=tOVUZqAPzyfc6ZXDHRyz5jp6OGzNJvv9CcyE-1bxtxI,3493
-pytemlib-0.2025.2.2.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
-pytemlib-0.2025.2.2.dist-info/entry_points.txt,sha256=zn2yO1IWTutI3c7C9e3GdARCvm43JURoOhqQ8YylV4Y,43
-pytemlib-0.2025.2.2.dist-info/top_level.txt,sha256=rPLVH0UJxrPSPgSoKScTjL1K_X69JFzsYYnDnYTYIlU,9
-pytemlib-0.2025.2.2.dist-info/RECORD,,
+pytemlib-0.2025.4.0.dist-info/licenses/LICENSE,sha256=7HdBF6SXIBd38bHOKkQd4DYR1KV-OYm9mwB16fM-984,1062
+pytemlib-0.2025.4.0.dist-info/METADATA,sha256=mV1ni5hE1q19Z8qOzNfWGb9YAOy0rv69JZd3J1e14MM,3515
+pytemlib-0.2025.4.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+pytemlib-0.2025.4.0.dist-info/entry_points.txt,sha256=zn2yO1IWTutI3c7C9e3GdARCvm43JURoOhqQ8YylV4Y,43
+pytemlib-0.2025.4.0.dist-info/top_level.txt,sha256=rPLVH0UJxrPSPgSoKScTjL1K_X69JFzsYYnDnYTYIlU,9
+pytemlib-0.2025.4.0.dist-info/RECORD,,

{pytemlib-0.2025.2.2.dist-info → pytemlib-0.2025.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.1)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any