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

pyTEMlib/file_tools.py

@@ -44,13 +44,202 @@ except ModuleNotFoundError:
 
 Dimension = sidpy.Dimension
 
-get_slope = sidpy.base.num_utils.get_slope
-__version__ = '2022.3.3'
+# 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
 import ipywidgets 
 
 
+@ipywidgets.register
+class FileWidget2(ipywidgets.DOMWidget):
+    """Widget to select directories or widgets from a list
+
+    Works in google colab.
+    The widget converts the name of the nion file to the one in Nion's swift software,
+    because it is otherwise incomprehensible
+
+    Attributes
+    ----------
+    dir_name: str
+        name of starting directory
+    extension: list of str
+        extensions of files to be listed  in widget
+
+    Methods
+    -------
+    get_directory
+    set_options
+    get_file_name
+
+    Example
+    -------
+    >>from google.colab import drive
+    >>drive.mount("/content/drive")
+    >>file_list = pyTEMlib.file_tools.FileWidget()
+    next code cell:
+    >>dataset = pyTEMlib.file_tools.open_file(file_list.file_name)
+
+    """
+
+    def __init__(self, dir_name=None, extension=['*'], sum_frames=False):
+        self.save_path = False
+        self.dir_dictionary = {}
+        self.dir_list = ['.', '..']
+        self.display_list = ['.', '..']
+        self.sum_frames = sum_frames
+
+        self.dir_name = '.'
+        if dir_name is None:
+            self.dir_name = get_last_path()
+            self.save_path = True
+        elif os.path.isdir(dir_name):
+            self.dir_name = dir_name
+
+        self.get_directory(self.dir_name)
+        self.dir_list = ['.']
+        self.extensions = extension
+        self.file_name = ''
+        self.datasets = {}
+        self.dataset = None
+
+        self.select_files = widgets.Select(
+            options=self.dir_list,
+            value=self.dir_list[0],
+            description='Select file:',
+            disabled=False,
+            rows=10,
+            layout=widgets.Layout(width='70%')
+        )
+        self.path_choice = widgets.Dropdown(options=['None'],
+                                            value='None',
+                                            description='directory:',
+                                            disabled=False,
+                                            button_style='',
+                                            layout=widgets.Layout(width='90%'))
+        
+        
+        
+        self.set_options()
+        ui = widgets.VBox([self.path_choice, self.select_files])
+        display(ui)
+        
+        self.select_files.observe(self.get_file_name, names='value')
+        self.path_choice.observe(self.set_dir, names='value')
+
+
+
+    def get_directory(self, directory=None):
+        self.dir_name = directory
+        self.dir_dictionary = {}
+        self.dir_list = []
+        self.dir_list = ['.', '..'] + os.listdir(directory)
+
+    def set_dir(self, value=0):
+        self.dir_name = self.path_choice.value
+        self.select_files.index = 0
+        self.set_options()
+
+
+    def set_options(self):
+        self.dir_name = os.path.abspath(os.path.join(self.dir_name, self.dir_list[self.select_files.index]))
+        dir_list = os.listdir(self.dir_name)
+        file_dict = update_directory_list(self.dir_name)
+
+        sort = np.argsort(file_dict['directory_list'])
+        self.dir_list = ['.', '..']
+        self.display_list = ['.', '..']
+        for j in sort:
+            self.display_list.append(f" * {file_dict['directory_list'][j]}")
+            self.dir_list.append(file_dict['directory_list'][j])
+
+        sort = np.argsort(file_dict['display_file_list'])
+
+        for i, j in enumerate(sort):
+            if '--' in dir_list[j]:
+                self.display_list.append(f" {i:3} {file_dict['display_file_list'][j]}")
+            else:
+                self.display_list.append(f" {i:3}   {file_dict['display_file_list'][j]}")
+            self.dir_list.append(file_dict['file_list'][j])
+
+        self.dir_label = os.path.split(self.dir_name)[-1] + ':'
+        self.select_files.options = self.display_list
+        
+        path = self.dir_name
+        old_path = ' '
+        path_list = []
+        while path != old_path:
+            path_list.append(path)
+            old_path = path
+            path = os.path.split(path)[0]
+        self.path_choice.options = path_list
+        self.path_choice.value = path_list[0]
+
+    def get_file_name(self, b):
+
+        if os.path.isdir(os.path.join(self.dir_name, self.dir_list[self.select_files.index])):
+            self.set_options()
+
+        elif os.path.isfile(os.path.join(self.dir_name, self.dir_list[self.select_files.index])):
+            self.file_name = os.path.join(self.dir_name, self.dir_list[self.select_files.index])
+
+class FileWidget3(FileWidget2):
+    def __init__(self, dir_name=None, extension=['*'], sum_frames=False):
+        if dir_name is None:
+            dir_name = get_last_path()
+            self.save_path = True     
+        super().__init__(dir_name=dir_name, extension=extension, sum_frames=sum_frames)
+        
+        select_button = widgets.Button(description='Select Main',
+                                       layout=widgets.Layout(width='auto', grid_area='header'),
+                                       style=widgets.ButtonStyle(button_color='lightblue'))
+        
+        add_button = widgets.Button(description='Add',
+                                    layout=widgets.Layout(width='auto', grid_area='header'),
+                                    style=widgets.ButtonStyle(button_color='lightblue'))
+        
+        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='')
+        
+        ui = widgets.HBox([select_button, add_button, self.loaded_datasets])
+        display(ui)
+        
+        
+        select_button.on_click(self.select_main)
+        add_button.on_click(self.add_dataset)
+        self.loaded_datasets.observe(self.select_dataset)
+    
+
+    def select_dataset(self, value=0):
+        key = self.loaded_datasets.value.split(':')[0]
+        if key != 'None':
+            self.selected_dataset = self.datasets[key]
+            self.selected_key = key
+
+    def select_main(self, value=0):
+        self.datasets = {}
+        self.dataset_list = []
+        self.datasets = open_file(self.file_name, sum_frames=self.sum_frames)
+        self.dataset_list = []
+        for key in self.datasets.keys():
+            self.dataset_list.append(f'{key}: {self.datasets[key].title}')
+        self.loaded_datasets.options = self.dataset_list
+        self.loaded_datasets.value = self.dataset_list[0]
+        self.dataset = self.datasets[list(self.datasets.keys())[0]]
+        self.selected_dataset = self.dataset
+
+    def add_dataset(self, value=0):
+        key = add_dataset_from_file(self.datasets, self.file_name, 'Channel')
+        self.dataset_list.append(f'{key}: {self.datasets[key].title}')
+        self.loaded_datasets.options = self.dataset_list
+        self.loaded_datasets.value = self.dataset_list[-1]
+    
+
 @ipywidgets.register
 class FileWidget(ipywidgets.DOMWidget):
     """Widget to select directories or widgets from a list
@@ -252,6 +441,8 @@ class ChooseDataset(object):
         else:
             self.reader = None
         self.get_dataset_list()
+        if len(self.dataset_list) < 1:
+            self.dataset_list = ['None']
         self.select_image = widgets.Dropdown(options=self.dataset_list,
                                              value=self.dataset_list[0],
                                              description='select dataset:',
@@ -266,6 +457,7 @@ class ChooseDataset(object):
 
     def get_dataset_list(self):
         """ Get by Log number sorted list of datasets"""
+        dataset_list = []
         if not isinstance(self.datasets, dict):
             dataset_list = self.reader.read()
             self.datasets = {}
@@ -287,10 +479,11 @@ class ChooseDataset(object):
 
     def set_dataset(self, b):
         index = self.select_image.index
-        self.key = self.dataset_names[index]
-        self.dataset = self.datasets[self.key]
-        self.dataset.title = self.dataset.title.split('/')[-1]
-        self.dataset.title = self.dataset.title.split('/')[-1]
+        if index < len(self.dataset_names):
+            self.key = self.dataset_names[index]
+            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):
@@ -512,7 +705,7 @@ def save_file_dialog_qt(file_types=None):  # , multiple_files=False):
         return filename
 
 
-def save_dataset(dataset, filename=None,  h5_group=None):
+def save_dataset(dataset, filename=None,  qt=False, h5_group=None):
     """ Saves a dataset to a file in pyNSID format
     Parameters
     ----------
@@ -523,7 +716,7 @@ def save_dataset(dataset, filename=None,  h5_group=None):
     h5_group: hd5py.Group
         not used yet
     """
-    if filename is None:
+    if filename is None or qt==True:
         filename = save_file_dialog_qt()
     h5_filename = get_h5_filename(filename)
     h5_file = h5py.File(h5_filename, mode='a')
@@ -594,8 +787,57 @@ def h5_group_to_dict(group, group_dict={}):
     return group_dict
 
 
+def read_annotation(image):
+    if 'MAGE' not in image.data_type.name:
+        return {}
+    scale_x = np.abs(image.x[1]-image.x[0])
+    scale_y = np.abs(image.y[1]-image.y[0])
+    rec_scale = np.array([scale_x, scale_y,scale_x, scale_y])
+    if 'DocumentObjectList' not in image.original_metadata:
+        return {}
+    if '0' not in image.original_metadata['DocumentObjectList']:
+        return {}
+    annotations = {}        
+    tags = image.original_metadata['DocumentObjectList']['0']     
+    for key in tags:
+        if 'AnnotationGroupList' in key:
+            an_tags = tags[key]
+            for key2 in an_tags:
+                if isinstance(an_tags[key2], dict):
+                    if an_tags[key2]['AnnotationType'] == 13:  #type 'text'
+                        annotations[key2] = {'type': 'text'}
+                        if 'Label' in an_tags:
+                            annotations[key2]['label'] = an_tags['Label']
+                        rect = np.array(an_tags[key2]['Rectangle']) * rec_scale
+                        annotations[key2]['position'] = [rect[1],rect[0]]
+                        annotations[key2]['text'] = an_tags['Text'] 
+                        
+                    elif an_tags[key2]['AnnotationType']==6:
+                        annotations[key2] = {'type': 'circle'}
+                        if 'Label' in an_tags:
+                            annotations[key2]['label'] = an_tags['Label']
+                        rect = np.array(an_tags[key2]['Rectangle']) * rec_scale
+                    
+                        annotations[key2]['radius'] =rect[3]-rect[1]
+                        annotations[key2]['position'] = [rect[1],rect[0]]
+        
+                    elif an_tags[key2]['AnnotationType'] == 23:
+                        annotations[key2] = {'type':  'spectral_image'}
+                        if 'Label' in an_tags[key2]:
+                            annotations[key2]['label'] = an_tags[key2]['Label']
+                        rect = np.array(an_tags[key2]['Rectangle']) * rec_scale
+                        
+                        annotations[key2]['width'] =rect[3]-rect[1]
+                        annotations[key2]['height'] =rect[2]-rect[0]
+                        annotations[key2]['position'] = [rect[1],rect[0]]
+                        annotations[key2]['Rectangle'] = np.array(an_tags[key2]['Rectangle'])
+    if len(annotations)>0:
+        image.metadata['annotations'] = annotations                
+    return annotations
+
+
 def open_file(filename=None,  h5_group=None, write_hdf_file=False, sum_frames=False):  # save_file=False,
-    """Opens a file if the extension is .hf5, .ndata, .dm3 or .dm4
+    """Opens a file if the extension is .emd, .mrc, .hf5, .ndata, .dm3 or .dm4
 
     If no filename is provided the QT open_file windows opens (if QT_available==True)
     Everything will be stored in a NSID style hf5 file.
@@ -640,24 +882,33 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False, sum_frames=Fa
             print('no hdf5 dataset found in file')
             return {}
         else:
-            dataset_dict = {}
-            for index, dataset in enumerate(datasets):
-                title = dataset.title.split('/')[2]
-                dataset.title = dataset.title.split('/')[-1]
-                dataset_dict[title] = dataset
-                if index == 0:
-                    file = datasets[0].h5_dataset.file
-                    master_group = datasets[0].h5_dataset.parent.parent.parent
-            for key in master_group.keys():
-                if key not in dataset_dict:
-                    dataset_dict[key] = h5_group_to_dict(master_group[key])
-            if not write_hdf_file:
-                file.close()
+            if isinstance(datasets, dict):
+                dataset_dict = datasets
+
+            else:    
+                dataset_dict = {}
+                for index, dataset in enumerate(datasets):
+                    title = str(dataset.title).split('/')[-1]
+                    # dataset.title = str(dataset.title).split('/')[-1]
+                    dataset_dict[title] = dataset
+                    if index == 0:
+                        file = datasets[0].h5_dataset.file
+                        master_group = datasets[0].h5_dataset.parent.parent.parent
+                for key in master_group.keys():
+                    if key not in dataset_dict:
+                        dataset_dict[key] = h5_group_to_dict(master_group[key])
+                if not write_hdf_file:
+                    file.close()
+            for dset in dataset_dict.values():
+                if isinstance(dset, sidpy.Dataset):
+                    if 'Measurement' in dset.title:
+                        dset.title = dset.title.split('/')[-1]
             return dataset_dict
-    elif extension in ['.dm3', '.dm4', '.ndata', '.ndata1', '.h5', '.emd', '.emi', '.edaxh5']:
+    elif extension in ['.dm3', '.dm4', '.ndata', '.ndata1', '.h5', '.emd', '.emi', '.edaxh5', '.mrc']:
         # tags = open_file(filename)
         if extension in ['.dm3', '.dm4']:
             reader = SciFiReaders.DMReader(filename)
+
         elif extension in ['.emi']:
             try:
                 import hyperspy.api as hs
@@ -682,7 +933,7 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False, sum_frames=Fa
                 return
         elif extension == '.emd':
             reader = SciFiReaders.EMDReader(filename, sum_frames=sum_frames)
-
+            
         elif 'edax' in extension.lower():
             if 'h5' in extension:
                 reader = SciFiReaders.EDAXReader(filename)
@@ -690,6 +941,9 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False, sum_frames=Fa
         elif extension in ['.ndata', '.h5']:
             reader = SciFiReaders.NionReader(filename)
 
+        elif extension in ['.mrc']:
+            reader = SciFiReaders.MRCReader(filename)
+
         else:
             raise NotImplementedError('extension not supported')
 
@@ -703,10 +957,44 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False, sum_frames=Fa
             if not isinstance(dset, dict):
                 print('Please use new SciFiReaders Package for full functionality')
             if isinstance(dset, sidpy.Dataset):
-                dset = [dset]
-            
+                dset = {'Channel_000': dset}
+            for key in dset:
+                read_annotation(dset[key])
+        if extension == '.emd':
+            for key1 in dset:
+                for key in dset[key1].original_metadata:
+                    if key == 'Instrument':
+                        model = dset[key1].original_metadata[key]['InstrumentModel']
+                        id = dset[key1].original_metadata[key]['InstrumentId']
+                        dset[key1].metadata['experiment']['instrument'] = model + str(id)
+                    if key == 'Optics':
+                        if 'LastMeasuredScreenCurrent' in dset[key1].original_metadata[key]:
+                            dset[key1].metadata['experiment']['current'] = float(dset[key1].original_metadata[key]['LastMeasuredScreenCurrent'])
+                    if key == 'Scan':
+                        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':
+                        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']
+                            for detector in dset[key1].original_metadata[key].values():
+                                if 'DetectorName' in detector:
+                                    if used_detector in detector['DetectorName']: 
+                                        if 'CollectionAngleRange' in detector:
+                                            begin = detector['CollectionAngleRange']['begin']
+                                            end = detector['CollectionAngleRange']['end']
+                                            dset[key1].metadata['experiment']['collection_angle'] = float(begin)
+                                            dset[key1].metadata['experiment']['collection_angle_end'] = float(end)
         if isinstance(dset, dict):
             dataset_dict = dset
+            for dataset in dataset_dict.values():
+                dataset.metadata['filename'] = filename
 
         elif isinstance(dset, list):
             if len(dset) < 1:
@@ -734,10 +1022,11 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False, sum_frames=Fa
 
         # Temporary Fix for dual eels spectra in dm files
         # Todo: Fic in ScifyReaders
-        for dset in dataset_dict.values():   
-            if 'single_exposure_time' in dset.metadata['experiment']:
-                dset.metadata['experiment']['exposure_time'] = dset.metadata['experiment']['number_of_frames'] * \
-                                                               dset.metadata['experiment']['single_exposure_time']
+        for dset in dataset_dict.values(): 
+            if 'experiment' in dset.metadata:
+                if 'single_exposure_time' in dset.metadata['experiment']:
+                    dset.metadata['experiment']['exposure_time'] = dset.metadata['experiment']['number_of_frames'] * \
+                                                                dset.metadata['experiment']['single_exposure_time']
         if write_hdf_file:
             h5_master_group = save_dataset(dataset_dict, filename=filename)
 

pyTEMlib/image_tools.py

@@ -15,7 +15,6 @@ import matplotlib.widgets as mwidgets
 import sidpy
 import pyTEMlib.file_tools as ft
 import pyTEMlib.sidpy_tools
-# import pyTEMlib.probe_tools
 
 from tqdm.auto import trange, tqdm
 
@@ -55,6 +54,12 @@ from skimage.filters import threshold_otsu, sobel
 from scipy.optimize import leastsq
 from sklearn.cluster import DBSCAN
 
+from ase.build import fcc110
+
+from scipy.ndimage import rotate
+from scipy.interpolate import RegularGridInterpolator
+from scipy.signal import fftconvolve
+
 
 _SimpleITK_present = True
 try:
@@ -68,6 +73,72 @@ if not _SimpleITK_present:
           'install with: conda install -c simpleitk simpleitk ')
 
 
+def get_atomic_pseudo_potential(fov, atoms, size=512, rotation=0):
+    # Big assumption: the atoms are not near the edge of the unit cell
+    # If any atoms are close to the edge (ex. [0,0]) then the potential will be clipped
+    # before calling the function, shift the atoms to the center of the unit cell
+
+    pixel_size = fov / size
+    max_size = int(size * np.sqrt(2) + 1)  # Maximum size to accommodate rotation
+
+    # Create unit cell potential
+    positions = atoms.get_positions()[:, :2]
+    atomic_numbers = atoms.get_atomic_numbers()
+    unit_cell_size = atoms.cell.cellpar()[:2]
+
+    unit_cell_potential = np.zeros((max_size, max_size))
+    for pos, atomic_number in zip(positions, atomic_numbers):
+        x = pos[0] / pixel_size
+        y = pos[1] / pixel_size
+        atom_width = 0.5  # Angstrom
+        gauss_width = atom_width/pixel_size # important for images at various fov.  Room for improvement with theory
+        gauss = pyTEMlib.probe_tools.make_gauss(max_size, max_size, width = gauss_width, x0=x, y0=y)
+        unit_cell_potential += gauss * atomic_number  # gauss is already normalized to 1
+
+    # Create interpolation function for unit cell potential
+    x_grid = np.linspace(0, fov * max_size / size, max_size)
+    y_grid = np.linspace(0, fov * max_size / size, max_size)
+    interpolator = RegularGridInterpolator((x_grid, y_grid), unit_cell_potential, bounds_error=False, fill_value=0)
+
+    # Vectorized computation of the full potential map with max_size
+    x_coords, y_coords = np.meshgrid(np.linspace(0, fov, max_size), np.linspace(0, fov, max_size), indexing="ij")
+    xtal_x = x_coords % unit_cell_size[0]
+    xtal_y = y_coords % unit_cell_size[1]
+    potential_map = interpolator((xtal_x.ravel(), xtal_y.ravel())).reshape(max_size, max_size)
+
+    # Rotate and crop the potential map
+    potential_map = rotate(potential_map, rotation, reshape=False)
+    center = potential_map.shape[0] // 2
+    potential_map = potential_map[center - size // 2:center + size // 2, center - size // 2:center + size // 2]
+
+    potential_map = scipy.ndimage.gaussian_filter(potential_map,3)
+
+    return potential_map
+
+def convolve_probe(ab, potential):
+    # the pixel sizes should be the exact same as the potential
+    final_sizes = potential.shape
+
+    # Perform FFT-based convolution
+    pad_height = pad_width = potential.shape[0] // 2
+    potential = np.pad(potential, ((pad_height, pad_height), (pad_width, pad_width)), mode='constant')
+
+    probe, A_k, chi = pyTEMlib.probe_tools.get_probe(ab, potential.shape[0], potential.shape[1],  scale = 'mrad', verbose= False)
+    
+
+    convolved = fftconvolve(potential, probe, mode='same')
+
+    # Crop to original potential size
+    start_row = pad_height
+    start_col = pad_width
+    end_row = start_row + final_sizes[0]
+    end_col = start_col + final_sizes[1]
+
+    image = convolved[start_row:end_row, start_col:end_col]   
+
+    return probe, image
+
+
 # Wavelength in 1/nm
 def get_wavelength(e0):
     """
@@ -280,20 +351,21 @@ def diffractogram_spots(dset, spot_threshold, return_center=True, eps=0.1):
     return spots, center
 
 
-def center_diffractogram(dset, return_plot = True, histogram_factor = None, smoothing = 1, min_samples = 100):
+def center_diffractogram(dset, return_plot = True, smoothing = 1, min_samples = 10, beamstop_size = 0.1):
     try:
         diff = np.array(dset).T.astype(np.float16)
         diff[diff < 0] = 0
-        
-        if histogram_factor is not None:
-            hist, bins = np.histogram(np.ravel(diff), bins=256, range=(0, 1), density=True)
-            threshold = threshold_otsu(diff, hist = hist * histogram_factor)
-        else:
-            threshold = threshold_otsu(diff)
+        threshold = threshold_otsu(diff)
         binary = (diff > threshold).astype(float)
         smoothed_image = ndimage.gaussian_filter(binary, sigma=smoothing) # Smooth before edge detection
         smooth_threshold = threshold_otsu(smoothed_image)
         smooth_binary = (smoothed_image > smooth_threshold).astype(float)
+
+        # add a circle to mask the beamstop
+        x, y = np.meshgrid(np.arange(dset.shape[0]), np.arange(dset.shape[1]))
+        circle = (x - dset.shape[0] / 2) ** 2 + (y - dset.shape[1] / 2) ** 2 < (beamstop_size * dset.shape[0] / 2) ** 2
+        smooth_binary[circle] = 1
+        
         # Find the edges using the Sobel operator
         edges = sobel(smooth_binary)
         edge_points = np.argwhere(edges)
@@ -322,18 +394,21 @@ def center_diffractogram(dset, return_plot = True, histogram_factor = None, smoo
     
     finally:
         if return_plot:
-            fig, ax = plt.subplots(1, 4, figsize=(10, 4))
+            fig, ax = plt.subplots(1, 5, figsize=(14, 4), sharex=True, sharey=True)
             ax[0].set_title('Diffractogram')
             ax[0].imshow(dset.T, cmap='viridis')
             ax[1].set_title('Otsu Binary Image')
             ax[1].imshow(binary, cmap='gray')
             ax[2].set_title('Smoothed Binary Image')
-            ax[2].imshow(smooth_binary, cmap='gray')
-            ax[3].set_title('Edge Detection and Fitting')
-            ax[3].imshow(edges, cmap='gray')
-            ax[3].scatter(center[0], center[1], c='r', s=10)
+            ax[2].imshow(smoothed_image, cmap='gray')
+
+            ax[3].set_title('Smoothed Binary Image')
+            ax[3].imshow(smooth_binary, cmap='gray')
+            ax[4].set_title('Edge Detection and Fitting')
+            ax[4].imshow(edges, cmap='gray')
+            ax[4].scatter(center[0], center[1], c='r', s=10)
             circle = plt.Circle(center, mean_radius, color='red', fill=False)
-            ax[3].add_artist(circle)
+            ax[4].add_artist(circle)
             for axis in ax:
                 axis.axis('off')
             fig.tight_layout()
@@ -522,6 +597,7 @@ def demon_registration(dataset, verbose=False):
     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:
@@ -610,6 +686,7 @@ def rigid_registration(dataset, sub_pixel=True):
     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['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'))
@@ -666,7 +743,6 @@ def rig_reg_drift(dset, rel_drift):
     rig_reg = np.zeros([dset.shape[frame_dim[0]], dset.shape[spatial_dim[0]], dset.shape[spatial_dim[1]]])
 
     # absolute drift
-    print(rel_drift)
     drift = np.array(rel_drift).copy()
     
     drift[0] = [0, 0]