pyTEMlib 0.2025.3.0__py3-none-any.whl → 0.2025.4.1__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/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
 
@@ -875,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):
@@ -917,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')
@@ -985,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):
@@ -1422,6 +1430,123 @@ 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']:
+        if 'ScanningDetector' in metadata_dict['Metadata']['Detectors']:
+            detector = metadata_dict['Metadata']['Detectors']['ScanningDetector']['DetectorName']
+        elif 'ImagingDetector' in metadata_dict['Metadata']['Detectors']:
+            detector = metadata_dict['Metadata']['Detectors']['ImagingDetector']['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 get_metadata_from_adorned(ds):
+    ds.metadata['experiment']= {}
+    if 'Optics' in ds.original_metadata:
+        if 'LastMeasuredScreenCurrent' in ds.original_metadata['Optics']:
+            ds.metadata['experiment']['current'] = float(ds.original_metadata['Optics']['LastMeasuredScreenCurrent'])
+        if 'ConvergenceAngle' in ds.original_metadata['Optics']:
+            ds.metadata['experiment']['convergence_angle'] = float(ds.original_metadata['Optics']['ConvergenceAngle'])  
+        if 'AccelerationVoltage' in ds.original_metadata['Optics']:
+            ds.metadata['experiment']['acceleration_voltage'] = float(ds.original_metadata['Optics']['AccelerationVoltage'])    
+        if 'SpotIndex' in ds.original_metadata['Optics']:
+            ds.metadata['experiment']['spot_size'] = ds.original_metadata['Optics']['SpotIndex']    
+    if' StagesSettings' in ds.original_metadata:
+        if 'StagePosition' in ds.original_metadata['StagesSettings']:
+            ds.metadata['experiment']['stage_position'] = ds.original_metadata['StagesSettings']['StagePosition']
+    if 'Detectors' in ds.original_metadata:
+        if 'ScanningDetector' in ds.original_metadata['Detectors']:
+            ds.metadata['experiment']['detector'] = ds.original_metadata['Detectors']['ScanningDetector']['DetectorName']
+        elif 'ImagingDetector' in ds.original_metadata['Detectors']:
+            ds.metadata['experiment']['detector'] = ds.original_metadata['Detectors']['ImagingDetector']['DetectorName'] 
+            ds.metadata['experiment']['exposure_time'] = ds.original_metadata['Detectors']['ImagingDetector']['ExposureTime']       
+            
+    
+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'))
+
+        get_metadata_from_adorned(ds)
+    return data_sets
+
 
 ###############################################
 # Support old pyTEM file format

pyTEMlib/graph_tools.py

@@ -808,15 +808,18 @@ 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 = main
+        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 = np.append(main, projection_tags['near_base'], axis=0)  # all nearest atoms
+        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) 
+
     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)
@@ -852,10 +855,17 @@ def breadth_first_search2(graph, initial, projected_crystal):
 
 
 
-def breath_first_search(graph, initial, lattice_parameter, tolerance=1):
+def breadth_first_search_felxible(graph, initial, lattice_parameter, tolerance=1):
     """ breadth first search of atoms viewed as a graph
-        we only 
+        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)

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))
@@ -229,7 +226,6 @@ def fourier_transform(dset: sidpy.Dataset) -> sidpy.Dataset:
 
     fft_dset.set_dimension(0, sidpy.Dimension(np.fft.fftshift(np.fft.fftfreq(new_image.shape[0],
                                                                              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],
@@ -599,13 +595,13 @@ 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
 
@@ -613,7 +609,7 @@ def demon_registration(dataset, verbose=False):
 ###############################
 # 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
 
@@ -635,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', 
@@ -688,21 +665,21 @@ 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})
 
@@ -778,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:
@@ -1416,8 +1392,6 @@ def decon_lr(o_image, probe,  verbose=False):
 
     response_ft = fftpack.fft2(probe_c)
 
-    
-
     ap_angle = o_image.metadata['experiment']['convergence_angle']
     if ap_angle > .1:
         ap_angle /= 1000  # now in rad
@@ -1452,7 +1426,7 @@ def decon_lr(o_image, probe,  verbose=False):
     # de = 100
     dest = 100
     i = 0
-    while abs(dest) > 0.001:  # or abs(de)  > .025:
+    while abs(dest) > 0.0001:  # or abs(de)  > .025:
         i += 1
         error_old = np.sum(error.real)
         est_old = est.copy()

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.03.0'
+_version = '0.2025.04.1'
 __version__ = _version
-_time = '2025-02-25 19:58:26'
+_time = '2025-05-25 19:58:26'

{pytemlib-0.2025.3.0.dist-info → pytemlib-0.2025.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyTEMlib
-Version: 0.2025.3.0
+Version: 0.2025.4.1
 Summary: pyTEM: TEM Data Quantification library through a model-based approach
 Home-page: https://pycroscopy.github.io/pyTEMlib/about.html
 Author: Gerd Duscher
@@ -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.3.0.dist-info → pytemlib-0.2025.4.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 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=XQk071ZHMGYOM6RTSIaXQlZtnFQjUyxTWbQ2ZXOFMfU,30901
 pyTEMlib/crystal_tools.py,sha256=g4OXyvd5NLw7vaXhjDP3P6VZpVV6eiyuPn8MdgR2amI,61652
@@ -10,13 +10,13 @@ pyTEMlib/eds_tools.py,sha256=Ilof2Cars-1ILXx5g2RsU2G4BgrPwjOHgQ7-OabmbrU,28000
 pyTEMlib/eels_dialog.py,sha256=QG_PU3uuzus_3I3zjfaxb2a9iYq8B053zYw-B52JklM,32595
 pyTEMlib/eels_dialog_utilities.py,sha256=73W9jFbPx-eeLEiSaBptTgGLr40bIYYfSyzLnZbhfvo,51761
 pyTEMlib/eels_tools.py,sha256=pl75ZDQHz1JngxD84T_595Kfrl5TEJSETPGgkXfBtrA,88688
-pyTEMlib/file_tools.py,sha256=liFMSpwHDXa0pbm0SAK5JQIhVLKkkGNPbrlC4UY5mQM,59467
+pyTEMlib/file_tools.py,sha256=RniTJrcuiyt7PefE5SSY_z2pTZPTNhFRjb2oVXVa4nE,66373
 pyTEMlib/file_tools_qt.py,sha256=tLZACS4JyGH_AOzNR_SGAhjA01y4VJB261opPhGMlm8,7223
-pyTEMlib/graph_tools.py,sha256=orNt4p765oODyL3oYWaFXjqNkaiocmCsnemc4qaxTbU,45996
+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=CyhcwaBbyi2j4DkUaG6dsKajaHl8BM-iPs6M9MmRhms,52896
+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=dKkAks0i6sJYBlVk2cRu2SHpr9fJbMu8gav2PVaKOW4,94
+pyTEMlib/version.py,sha256=1mG-HaMBzuYiDf1nig-t9gxjgThQprsDbDaDFGoWGBY,94
 pyTEMlib/xrpa_x_sections.py,sha256=m4gaH7gaJiNi-CsIT9aKoH4fB6MQIAe876kxEmzSebI,1825392
-pytemlib-0.2025.3.0.dist-info/LICENSE,sha256=7HdBF6SXIBd38bHOKkQd4DYR1KV-OYm9mwB16fM-984,1062
-pytemlib-0.2025.3.0.dist-info/METADATA,sha256=BqNTNOrFTLzDmoIE5uLAIUnvwDXmtkl2ZPRTK5DnwfE,3493
-pytemlib-0.2025.3.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-pytemlib-0.2025.3.0.dist-info/entry_points.txt,sha256=zn2yO1IWTutI3c7C9e3GdARCvm43JURoOhqQ8YylV4Y,43
-pytemlib-0.2025.3.0.dist-info/top_level.txt,sha256=rPLVH0UJxrPSPgSoKScTjL1K_X69JFzsYYnDnYTYIlU,9
-pytemlib-0.2025.3.0.dist-info/RECORD,,
+pytemlib-0.2025.4.1.dist-info/licenses/LICENSE,sha256=7HdBF6SXIBd38bHOKkQd4DYR1KV-OYm9mwB16fM-984,1062
+pytemlib-0.2025.4.1.dist-info/METADATA,sha256=Cp3K3rOFMT-MZjC2EK0mKXBYU495_9UFUkZlg2yIH9Y,3515
+pytemlib-0.2025.4.1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+pytemlib-0.2025.4.1.dist-info/entry_points.txt,sha256=zn2yO1IWTutI3c7C9e3GdARCvm43JURoOhqQ8YylV4Y,43
+pytemlib-0.2025.4.1.dist-info/top_level.txt,sha256=rPLVH0UJxrPSPgSoKScTjL1K_X69JFzsYYnDnYTYIlU,9
+pytemlib-0.2025.4.1.dist-info/RECORD,,

{pytemlib-0.2025.3.0.dist-info → pytemlib-0.2025.4.1.dist-info}/WHEEL

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