pyTEMlib 0.2025.2.1__tar.gz → 0.2025.3.0__tar.gz

{pytemlib-0.2025.2.1/pyTEMlib.egg-info → pytemlib-0.2025.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pyTEMlib
-Version: 0.2025.2.1
+Version: 0.2025.3.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

{pytemlib-0.2025.2.1 → pytemlib-0.2025.3.0}/pyTEMlib/core_loss_widget.py

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

{pytemlib-0.2025.2.1 → pytemlib-0.2025.3.0}/pyTEMlib/eels_dialog.py

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

{pytemlib-0.2025.2.1 → pytemlib-0.2025.3.0}/pyTEMlib/eels_tools.py

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

{pytemlib-0.2025.2.1 → pytemlib-0.2025.3.0}/pyTEMlib/file_tools.py

@@ -33,8 +33,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 +42,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 +112,6 @@ class FileWidget2(ipywidgets.DOMWidget):
                                             value='None',
                                             description='directory:',
                                             disabled=False,
-                                            button_style='',
                                             layout=widgets.Layout(width='90%'))
         
         
@@ -203,8 +198,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 +307,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 +438,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 +475,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)
@@ -968,13 +959,18 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False, sum_frames=Fa
                         id = dset[key1].original_metadata[key]['InstrumentId']
                         dset[key1].metadata['experiment']['instrument'] = model + str(id)
                     if key == 'Optics':
-                        dset[key1].metadata['experiment']['current'] = float(dset[key1].original_metadata[key]['LastMeasuredScreenCurrent'])
+                        if 'LastMeasuredScreenCurrent' in dset[key1].original_metadata[key]:
+                            dset[key1].metadata['experiment']['current'] = float(dset[key1].original_metadata[key]['LastMeasuredScreenCurrent'])
                     if key == 'Scan':
-                        dset[key1].metadata['experiment']['pixel_time'] = float(dset[key1].original_metadata[key]['DwellTime'])
-                        dset[key1].metadata['experiment']['exposure_time'] = float(dset[key1].original_metadata[key]['FrameTime'])
+                        if 'DwellTime' in dset[key1].original_metadata[key]:
+                            dset[key1].metadata['experiment']['pixel_time'] = float(dset[key1].original_metadata[key]['DwellTime'])
+                        if 'FrameTime' in dset[key1].original_metadata[key]:
+                            dset[key1].metadata['experiment']['exposure_time'] = float(dset[key1].original_metadata[key]['FrameTime'])
                     if  key == 'Sample':
-                        dset[key1].metadata['experiment']['sample'] = dset[key1].original_metadata[key]['SampleDescription']
-                        dset[key1].metadata['experiment']['sample_id'] = dset[key1].original_metadata[key]['SampleId']    
+                        if 'SampleDescription' in dset[key1].original_metadata[key]:
+                            dset[key1].metadata['experiment']['sample'] = dset[key1].original_metadata[key]['SampleDescription']
+                        if 'SampleId' in dset[key1].original_metadata[key]:
+                            dset[key1].metadata['experiment']['sample_id'] = dset[key1].original_metadata[key]['SampleId']    
                     if key == 'Detectors':
                         if 'detector' in dset[key1].metadata['experiment']:
                             used_detector = dset[key1].metadata['experiment']['detector']

{pytemlib-0.2025.2.1 → pytemlib-0.2025.3.0}/pyTEMlib/graph_tools.py

@@ -5,7 +5,6 @@ import numpy as np
 # import ase
 import sys
 
-# from scipy.spatial import cKDTree, Voronoi, ConvexHull
 import scipy.spatial
 import scipy.optimize
 import scipy.interpolate
@@ -20,7 +19,7 @@ import pyTEMlib.crystal_tools
 from tqdm.auto import tqdm, trange
 
 from .graph_viz import *
-
+QT_available = False
 
 ###########################################################################
 # utility functions
@@ -212,6 +211,14 @@ def get_voronoi(tetrahedra, atoms, bond_radii=None, optimize=True):
     """
 
     extent = atoms.cell.lengths()
+    print('extent', extent)
+
+    if np.abs(atoms.positions[:, 2]).sum() <= 0.01:
+        positions = atoms.positions[:, :2]
+        extent = extent[:2]
+    else:
+        positions = atoms.positions
+
     if atoms.info is None:
         atoms.info = {}
 
@@ -232,8 +239,8 @@ def get_voronoi(tetrahedra, atoms, bond_radii=None, optimize=True):
         r_a = []
         for vert in vertices:
             r_a.append(bond_radii[vert])
-        voronoi, radius = interstitial_sphere_center(atoms.positions[vertices], r_a, optimize=optimize)
-
+        voronoi, radius = interstitial_sphere_center(positions[vertices], r_a, optimize=optimize)
+    
         r_a = np.average(r_a)  # np.min(r_a)
         r_aa.append(r_a)
 
@@ -247,7 +254,7 @@ def get_voronoi(tetrahedra, atoms, bond_radii=None, optimize=True):
 def find_overlapping_spheres(voronoi_vertices, r_vv, r_a, cheat=1.):
     """Find overlapping spheres"""
 
-    vertex_tree = scipy.spatial.cKDTree(voronoi_vertices)
+    vertex_tree = scipy.spatial.KDTree(voronoi_vertices)
 
     pairs = vertex_tree.query_pairs(r=r_a * 2)
 
@@ -424,7 +431,7 @@ def get_non_periodic_supercell(super_cell):
     return atoms
 
 def get_connectivity_matrix(crystal, atoms, polyhedra):
-    crystal_tree = scipy.spatial.cKDTree(crystal.positions)
+    crystal_tree = scipy.spatial.KDTree(crystal.positions)
     
     
     connectivity_matrix = np.zeros([len(atoms),len(atoms)], dtype=int)
@@ -476,8 +483,8 @@ def get_bonds(crystal, shift= 0., verbose = False, cheat=1.0):
     other = []
     super_cell_atoms =[]
     
-    atoms_tree = scipy.spatial.cKDTree(atoms.positions-crystal.cell.lengths())
-    crystal_tree = scipy.spatial.cKDTree(crystal.positions)
+    atoms_tree = scipy.spatial.KDTree(atoms.positions-crystal.cell.lengths())
+    crystal_tree = scipy.spatial.KDTree(crystal.positions)
     connectivity_matrix = np.zeros([len(atoms),len(atoms)], dtype=float)
     
     for polyhedron in polyhedra.values():
@@ -699,18 +706,21 @@ def find_polyhedra(atoms, optimize=True, cheat=1.0, bond_radii=None):
         raise TypeError('This function needs an ase.Atoms object')
 
     if np.abs(atoms.positions[:, 2]).sum() <= 0.01:
-        tetrahedra = scipy.spatial.Delaunay(atoms.positions[:, :2])
+        positions = atoms.positions[:, :2]
+        print('2D')
     else:
-        tetrahedra = scipy.spatial.Delaunay(atoms.positions)
+        positions = atoms.positions
+    tetrahedra = scipy.spatial.Delaunay(positions)
 
     voronoi_vertices, voronoi_tetrahedrons, r_vv, r_a = get_voronoi(tetrahedra, atoms, optimize=optimize, bond_radii=bond_radii)
-    if np.abs(atoms.positions[:, 2]).sum() <= 0.01:
-        r_vv = np.array(r_vv)*3.
+    
+    if positions.shape[1] < 3:
+        r_vv = np.array(r_vv)*1.
     overlapping_pairs = find_overlapping_spheres(voronoi_vertices, r_vv, r_a, cheat=cheat)
 
     clusters, visited_all = find_interstitial_clusters(overlapping_pairs)
 
-    if np.abs(atoms.positions[:, 2]).sum() <= 0.01:
+    if positions.shape[1] < 3:
         rings = get_polygons(atoms, clusters, voronoi_tetrahedrons)
         return rings
     else:
@@ -770,7 +780,7 @@ def sort_polyhedra_by_vertices(polyhedra, visible=range(4, 100), z_lim=[0, 100],
 ##########################
 # New Graph Stuff
 ##########################
-def breadth_first_search(graph, initial, projected_crystal):
+def breadth_first_search2(graph, initial, projected_crystal):
     """ breadth first search of atoms viewed as a graph
 
     the projection dictionary has to contain the following items
@@ -794,15 +804,20 @@ 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 = main
+    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
     # get k next nearest neighbours for each node
-    neighbour_tree = scipy.spatial.cKDTree(graph)
+    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 +850,46 @@ def breadth_first_search(graph, initial, projected_crystal):
 
     return graph[visited], ideal
 
+
+
+def breath_first_search(graph, initial, lattice_parameter, tolerance=1):
+    """ breadth first search of atoms viewed as a graph
+        we only 
+    """
+    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 +1047,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 +1201,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-0.2025.2.1 → pytemlib-0.2025.3.0}/pyTEMlib/image_tools.py

@@ -212,6 +212,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 +228,12 @@ 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 +320,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 +519,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 +584,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)
@@ -603,6 +606,7 @@ def demon_registration(dataset, verbose=False):
     if 'input_shape' in dataset.metadata:
         demon_registered.metadata['input_shape'] = dataset.metadata['input_shape']
     demon_registered.metadata['input_dataset'] = dataset.source
+    demon_registered.data_type = 'IMAGE_STACK'
     return demon_registered
 
 
@@ -699,6 +703,7 @@ def rigid_registration(dataset, sub_pixel=True):
     rigid_registered.set_dimension(2, sidpy.Dimension(array_y,
                                           'y', units='nm', quantity='Length',
                                           dimension_type='spatial'))
+    rigid_registered.data_type = 'IMAGE_STACK'
     return rigid_registered.rechunk({0: 'auto', 1: -1, 2: -1})
 
 
@@ -902,9 +907,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 +1106,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 +1115,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 +1409,18 @@ 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'])
 
@@ -1438,19 +1452,16 @@ def decon_lr(o_image, probe,  verbose=False):
     # de = 100
     dest = 100
     i = 0
-    while abs(dest) > 0.0001:  # or abs(de)  > .025:
+    while abs(dest) > 0.001:  # or abs(de)  > .025:
         i += 1
         error_old = np.sum(error.real)
         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 +1477,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-0.2025.3.0/pyTEMlib/version.py

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

{pytemlib-0.2025.2.1 → pytemlib-0.2025.3.0/pyTEMlib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pyTEMlib
-Version: 0.2025.2.1
+Version: 0.2025.3.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

{pytemlib-0.2025.2.1 → pytemlib-0.2025.3.0}/pyTEMlib.egg-info/requires.txt

@@ -12,5 +12,5 @@ spglib
 scikit-image
 scikit-learn
 pyNSID>=0.0.7
-sidpy>=0.12.1
+sidpy>=0.12.7
 SciFiReaders>=0.0.8

{pytemlib-0.2025.2.1 → pytemlib-0.2025.3.0}/setup.py

@@ -49,7 +49,7 @@ setuptools.setup(
     author_email="gduscher@utk.edu",
 
     install_requires=['scipy', 'numpy', 'pillow',  'ase', 'tqdm', 'plotly', 'pandas', 'requests', 'lxml', 'ipympl',  
-                      'spglib', 'scikit-image', 'scikit-learn', 'pyNSID>=0.0.7', 'sidpy>=0.12.1', 'SciFiReaders>=0.0.8'],  # 'PyQt5> 1.0'],#
+                      'spglib', 'scikit-image', 'scikit-learn', 'pyNSID>=0.0.7', 'sidpy>=0.12.7', 'SciFiReaders>=0.0.8'],  # 'PyQt5> 1.0'],#
     setup_requires=['pytest-runner'],
     tests_require=['pytest'],
     platforms=['Linux', 'Mac OSX', 'Windows 11/10'],

pytemlib-0.2025.2.1/pyTEMlib/version.py

@@ -1,6 +0,0 @@
-"""
-version
-"""
-_version = '0.2025.02.1'
-__version__ = _version
-_time = '2025-02-23 19:58:26'