pyTEMlib 0.2023.8.0__py2.py3-none-any.whl → 0.2024.2.0__py2.py3-none-any.whl

pyTEMlib/file_tools.py

@@ -47,8 +47,12 @@ Dimension = sidpy.Dimension
 get_slope = sidpy.base.num_utils.get_slope
 __version__ = '2022.3.3'
 
+from traitlets import Unicode, Bool, validate, TraitError
+import ipywidgets 
 
-class FileWidget(object):
+
+@ipywidgets.register
+class FileWidget(ipywidgets.DOMWidget):
     """Widget to select directories or widgets from a list
 
     Works in google colab.
@@ -95,7 +99,7 @@ class FileWidget(object):
         self.dir_list = ['.']
         self.extensions = extension
         self.file_name = ''
-        self.datasets ={}
+        self.datasets = {}
         self.dataset = None
 
         self.select_files = widgets.Select(
@@ -108,28 +112,29 @@ class FileWidget(object):
         )
         
         select_button = widgets.Button(description='Select Main',
-                     layout=widgets.Layout(width='auto', grid_area='header'),
-                     style=widgets.ButtonStyle(button_color='lightblue'))
+                                       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'))
+                                    layout=widgets.Layout(width='auto', grid_area='header'),
+                                    style=widgets.ButtonStyle(button_color='lightblue'))
         
         self.path_choice = widgets.Dropdown(options=['None'],
-                                             value='None',
-                                             description='directory:',
-                                             disabled=False,
-                                             button_style='',
-                                             layout=widgets.Layout(width='90%'))
+                                            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='')
+                                                value=self.dataset_list[0],
+                                                description='loaded datasets:',
+                                                disabled=False,
+                                                button_style='')
         
         self.set_options()
-        ui = widgets.VBox([self.path_choice, self.select_files, widgets.HBox([select_button, add_button, self.loaded_datasets])])
+        ui = widgets.VBox([self.path_choice, self.select_files, widgets.HBox([select_button, add_button,
+                                                                              self.loaded_datasets])])
         display(ui)
         
         self.select_files.observe(self.get_file_name, names='value')
@@ -137,18 +142,21 @@ class FileWidget(object):
 
         select_button.on_click(self.select_main)
         add_button.on_click(self.add_dataset)
-        self.loaded_datasets.observe(self.selected_dataset)
+        self.loaded_datasets.observe(self.select_dataset)
 
     def select_main(self, value=0):
         self.datasets = {}
-        self.loaded_datasets.value = self.dataset_list[0]
+        #self.loaded_datasets.value = self.dataset_list[0]
+        self.dataset_list = []
         self.datasets = open_file(self.file_name)
         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.debug = 5
         self.dataset = self.datasets[list(self.datasets.keys())[0]]
+        self.debug = 6
         self.selected_dataset = self.dataset
         
     def add_dataset(self, value=0):
@@ -168,11 +176,12 @@ class FileWidget(object):
         self.select_files.index = 0
         self.set_options()
 
-    def selected_dataset(self, value=0):
+    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 set_options(self):
         self.dir_name = os.path.abspath(os.path.join(self.dir_name, self.dir_list[self.select_files.index]))
@@ -368,6 +377,9 @@ def get_last_path():
 
     if len(path) < 2:
         path = '.'
+    else:
+        if not os.path.exists(path):
+            path = '.'
     return path
 
 
@@ -451,6 +463,7 @@ def open_file_dialog_qt(file_types=None):  # , multiple_files=False):
         save_path(filename)
         return filename
 
+
 def save_file_dialog_qt(file_types=None):  # , multiple_files=False):
     """Opens a File dialog which is used in open_file() function
 
@@ -488,10 +501,6 @@ def save_file_dialog_qt(file_types=None):  # , multiple_files=False):
         file_types = 'TEM files (*.dm3 *.dm4 *.emd *.ndata *.h5 *.hf5);;pyNSID files (*.hf5);;QF files ( *.qf3);;' \
                      'DM files (*.dm3 *.dm4);;Nion files (*.ndata *.h5);;All files (*)'
 
-        
-        # file_types = [("TEM files",["*.dm*","*.hf*","*.ndata" ]),("pyNSID files","*.hf5"),("DM files","*.dm*"),
-        # ("Nion files",["*.h5","*.ndata"]),("all files","*.*")]
-
     # Determine last path used
     path = get_last_path()
 
@@ -639,28 +648,15 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False):  # save_file
                     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])
-                    print()
             if not write_hdf_file:
                 file.close()
-                # datasets[0].h5_dataset = None
             return dataset_dict
-
-        """ 
-        should go to no dataset found
-        if 'Raw_Data' in h5_group:
-            dataset = read_old_h5group(h5_group)
-            dataset.h5_dataset = h5_group['Raw_Data']
-        """
-
-    elif extension in ['.dm3', '.dm4', '.ndata', '.ndata1', '.h5', '.emd', '.emi']:
-
+    elif extension in ['.dm3', '.dm4', '.ndata', '.ndata1', '.h5', '.emd', '.emi', '.edaxh5']:
         # tags = open_file(filename)
         if extension in ['.dm3', '.dm4']:
             reader = SciFiReaders.DMReader(filename)
-
         elif extension in ['.emi']:
             try:
                 import hyperspy.api as hs
@@ -673,12 +669,12 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False):  # save_file
                     dset = SciFiReaders.convert_hyperspy(datum)
                     if datum.data.ndim == 1:
                         dset.title = dset.title + f'_{spectrum_number}_Spectrum'
-                        spectrum_number +=1
+                        spectrum_number += 1
                     elif datum.data.ndim == 3:
-                        dset.title = dset.title +'_SI'
+                        dset.title = dset.title + '_SI'
                     dset = dset.T
                     dset.title = dset.title[11:]
-                    dataset_dict[f'Channel_{index:03d}']=dset
+                    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')
@@ -686,6 +682,10 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False):  # save_file
         elif extension == '.emd':
             reader = SciFiReaders.EMDReader(filename)
 
+        elif 'edax' in extension.lower():
+            if 'h5' in extension:
+                reader = SciFiReaders.EDAXReader(filename)
+
         elif extension in ['.ndata', '.h5']:
             reader = SciFiReaders.NionReader(filename)
 
@@ -699,18 +699,22 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False):  # save_file
 
         if extension in ['.dm3', '.dm4']:
             title = (basename.strip().replace('-', '_')).split('/')[-1]
-            if not isinstance(dset, list):
+            if not isinstance(dset, dict):
                 print('Please use new SciFiReaders Package for full functionality')
+            if isinstance(dset, sidpy.Dataset):
                 dset = [dset]
-            if 'PageSetup' in dset[0].original_metadata:
-                del dset[0].original_metadata['PageSetup']
-            dset[0].original_metadata['original_title'] = title
+            
+        if isinstance(dset, dict):
+            dataset_dict = dset
 
-        if isinstance(dset, list):
+        elif isinstance(dset, list):
             if len(dset) < 1:
                 print('no dataset found in file')
                 return {}
             else:
+                if 'PageSetup' in dset[0].original_metadata:
+                    del dset[0].original_metadata['PageSetup']
+                    dset[0].original_metadata['original_title'] = title
                 dataset_dict = {}
                 for index, dataset in enumerate(dset):
                     if extension == '.emi':
@@ -963,7 +967,7 @@ def add_dataset_from_file(datasets, filename=None, key_name='Log', single_datase
         actual last used name of dictionary key
     """
 
-    datasets2 =  open_file(filename=filename)
+    datasets2 = open_file(filename=filename)
     first_dataset = datasets2[list(datasets2)[0]]
     if isinstance(first_dataset, sidpy.Dataset):
             
@@ -973,10 +977,10 @@ def add_dataset_from_file(datasets, filename=None, key_name='Log', single_datase
                 if int(key[-3:]) >= index:
                     index = int(key[-3:])+1
         if single_dataset:
-            datasets[key_name+f'_{index:03}'] =  first_dataset
+            datasets[key_name+f'_{index:03}'] = first_dataset
         else:
             for dataset in datasets2.values():
-                datasets[key_name+f'_{index:03}'] =  dataset
+                datasets[key_name+f'_{index:03}'] = dataset
                 index += 1
             index -= 1
     else:

pyTEMlib/graph_tools.py

@@ -797,15 +797,14 @@ def breadth_first_search(graph, initial, projected_crystal):
 
     # get lattice vectors to hopp along through graph
     projected_unit_cell = projected_crystal.cell[:2, :2]
-    a_lattice_vector = projected_unit_cell[0]/10
-    b_lattice_vector = projected_unit_cell[1]/10
-    print(a_lattice_vector, b_lattice_vector)
+    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)
     distances, indices = neighbour_tree.query(graph,  # let's get all neighbours
-                                              k=8)  # projection_tags['number_of_nearest_neighbours']*2 + 1)
+                                              k=50)  # projection_tags['number_of_nearest_neighbours']*2 + 1)
     # print(projection_tags['number_of_nearest_neighbours'] * 2 + 1)
     visited = []  # the atoms we visited
     ideal = []  # atoms at ideal lattice

pyTEMlib/image_tools.py

@@ -6,7 +6,7 @@ MIT license except where stated differently
 """
 
 import numpy as np
-
+import matplotlib
 import matplotlib as mpl
 import matplotlib.pylab as plt
 import matplotlib.widgets as mwidgets
@@ -23,6 +23,7 @@ from tqdm.auto import trange, tqdm
 from itertools import product
 
 from scipy import fftpack
+import scipy
 # from scipy import signal
 from scipy.interpolate import interp1d  # , interp2d
 import scipy.optimize as optimization
@@ -45,6 +46,10 @@ from skimage.feature import blob_log  # blob_dog, blob_doh
 
 from sklearn.feature_extraction import image
 from sklearn.utils.extmath import randomized_svd
+from sklearn.cluster import DBSCAN
+
+from collections import Counter
+
 
 _SimpleITK_present = True
 try:
@@ -77,7 +82,7 @@ def get_wavelength(e0):
     return const.h/np.sqrt(2*const.m_e*eV*(1+eV/(2*const.m_e*const.c**2)))*10**9
 
 
-def fourier_transform(dset):
+def fourier_transform(dset: sidpy.Dataset) -> sidpy.Dataset:
     """
         Reads information into dictionary 'tags', performs 'FFT', and provides a smoothed FT and reciprocal
         and intensity limits for visualization.
@@ -111,7 +116,7 @@ def fourier_transform(dset):
         if len(image_dim) != 2:
             raise ValueError('need at least two SPATIAL dimension for an image stack')
 
-        for i in range(dset.dims):
+        for i in range(dset.ndim):
             if i in image_dim:
                 selection.append(slice(None))
             if len(stack_dim) == 0:
@@ -202,7 +207,7 @@ def power_spectrum(dset, smoothing=3):
     return power_spec
 
 
-def diffractogram_spots(dset, spot_threshold):
+def diffractogram_spots(dset, spot_threshold, return_center=True, eps=0.1):
     """Find spots in diffractogram and sort them by distance from center
 
     Uses blob_log from scipy.spatial
@@ -213,6 +218,10 @@ def diffractogram_spots(dset, spot_threshold):
         diffractogram
     spot_threshold: float
         threshold for blob finder
+    return_center: bool, optional
+        return center of image if true
+    eps: float, optional
+        threshold for blob finder
 
     Returns
     -------
@@ -242,7 +251,28 @@ def diffractogram_spots(dset, spot_threshold):
     spots = spots_random[spots_index]
     # third row is angles
     spots[:, 2] = np.arctan2(spots[:, 0], spots[:, 1])
-    return spots
+
+    center = [0, 0]
+
+    if return_center:
+        points = spots[:, 0:2]
+
+        # Calculate the midpoints between all points
+        reshaped_points = points[:, np.newaxis, :]
+        midpoints = (reshaped_points + reshaped_points.transpose(1, 0, 2)) / 2.0
+        midpoints = midpoints.reshape(-1, 2)
+
+        # Find the most dense cluster of midpoints
+        dbscan = DBSCAN(eps=eps, min_samples=2)
+        labels = dbscan.fit_predict(midpoints)
+        cluster_counter = Counter(labels)
+        largest_cluster_label = max(cluster_counter, key=cluster_counter.get)
+        largest_cluster_points = midpoints[labels == largest_cluster_label]
+
+        # Average of these midpoints must be the center
+        center = np.mean(largest_cluster_points, axis=0)
+
+    return spots, center
 
 
 def adaptive_fourier_filter(dset, spots, low_pass=3, reflection_radius=0.3):
@@ -344,16 +374,17 @@ def complete_registration(main_dataset, storage_channel=None):
     print('Rigid_Registration')
 
     rigid_registered_dataset = rigid_registration(main_dataset)
-    if storage_channel is None:
-        storage_channel = main_dataset.h5_dataset.parent.parent
 
-    registration_channel = ft.log_results(storage_channel, rigid_registered_dataset)
+    if storage_channel is not None:
+        registration_channel = ft.log_results(storage_channel, rigid_registered_dataset)
 
     print('Non-Rigid_Registration')
 
     non_rigid_registered = demon_registration(rigid_registered_dataset)
-    registration_channel = ft.log_results(storage_channel, non_rigid_registered)
+    if storage_channel is not None:
+        registration_channel = ft.log_results(storage_channel, non_rigid_registered)
 
+    non_rigid_registered.h5_dataset = registration_channel
     return non_rigid_registered, rigid_registered_dataset
 
 
@@ -413,8 +444,6 @@ def demon_registration(dataset, verbose=False):
     resampler.SetInterpolator(sitk.sitkBSpline)
     resampler.SetDefaultPixelValue(0)
 
-    done = 0
-
     for i in trange(nimages):
 
         moving = sitk.GetImageFromArray(dataset[i])
@@ -492,7 +521,7 @@ def rigid_registration(dataset):
           ' pixels in y-direction')
     
     fixed = dataset[tuple(selection)].squeeze().compute()
-    fft_fixed =  np.fft.fft2(fixed)
+    fft_fixed = np.fft.fft2(fixed)
     
     relative_drift = [[0., 0.]]
     
@@ -502,12 +531,10 @@ def rigid_registration(dataset):
         fft_moving = np.fft.fft2(moving)
         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
+        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)
     
     rigid_registered = dataset.like_data(crop_reg)
@@ -515,18 +542,12 @@ def rigid_registration(dataset):
     rigid_registered.source = dataset.title
     rigid_registered.metadata = {'analysis': 'rigid sub-pixel registration', 'drift': drift,
                                  'input_crop': input_crop, 'input_shape': dataset.shape[1:]}
-    if hasattr(rigid_registered, 'z'):
-        del rigid_registered.z
-    if hasattr(rigid_registered, 'x'):
-        del rigid_registered.x
-    if hasattr(rigid_registered, 'y'):
-        del rigid_registered.y
-    # rigid_registered._axes = {}
     rigid_registered.set_dimension(0, dataset._axes[frame_dim[0]])
     rigid_registered.set_dimension(1, dataset._axes[spatial_dim[0]][input_crop[0]:input_crop[1]])
     rigid_registered.set_dimension(2, dataset._axes[spatial_dim[1]][input_crop[2]:input_crop[3]])
     return rigid_registered.rechunk({0: 'auto', 1: -1, 2: -1})
 
+
 def rig_reg_drift(dset, rel_drift):
     """ Shifting images on top of each other
 
@@ -579,7 +600,8 @@ def rig_reg_drift(dset, rel_drift):
     for i in range(rig_reg.shape[0]):
         selection[frame_dim[0]] = slice(i, i+1)
         # Now we shift
-        rig_reg[i, :, :] = ndimage.shift(dset[tuple(selection)].squeeze().compute(), [drift[i, 0], drift[i, 1]], order=3)
+        rig_reg[i, :, :] = ndimage.shift(dset[tuple(selection)].squeeze().compute(),
+                                         [drift[i, 0], drift[i, 1]], order=3)
     return rig_reg, drift
 
 
@@ -605,6 +627,7 @@ def crop_image_stack(rig_reg, drift):
 
     return rig_reg[:, xpmin:xpmax, ypmin:ypmax], [xpmin, xpmax, ypmin, ypmax]
 
+
 class ImageWithLineProfile:
     """Image with line profile"""
 
@@ -673,6 +696,112 @@ class ImageWithLineProfile:
         self.ax[1].draw()
 
 
+class LineSelector(matplotlib.widgets.PolygonSelector):
+    def __init__(self, ax, onselect, line_width=1, **kwargs):
+        super().__init__(ax, onselect, **kwargs)
+        bounds = ax.viewLim.get_points()
+        np.max(bounds[0])
+        self.line_verts = np.array([[np.max(bounds[1])/2, np.max(bounds[0])/5], [np.max(bounds[1])/2,
+                                                                                 np.max(bounds[0])/5+1],
+                                    [np.max(bounds[1])/5, np.max(bounds[0])/2], [np.max(bounds[1])/5,
+                                                                                 np.max(bounds[0])/2]])
+        self.verts = self.line_verts
+        self.line_width = line_width
+
+    def set_linewidth(self, line_width=None):
+        if line_width is not None:
+            self.line_width = line_width
+
+        m = -(self.line_verts[0, 1]-self.line_verts[3, 1])/(self.line_verts[0, 0]-self.line_verts[3, 0])
+        c = 1/np.sqrt(1+m**2)
+        s = c*m
+        self.line_verts[1] = [self.line_verts[0, 0]+self.line_width*s, self.line_verts[0, 1]+self.line_width*c]
+        self.line_verts[2] = [self.line_verts[3, 0]+self.line_width*s, self.line_verts[3, 1]+self.line_width*c]
+        
+        self.verts = self.line_verts.copy()
+
+    def onmove(self, event):
+        super().onmove(event)
+        if np.max(np.linalg.norm(self.line_verts-self.verts, axis=1)) > 1:
+            self.moved_point = np.argmax(np.linalg.norm(self.line_verts-self.verts, axis=1))
+            
+            self.new_point = self.verts[self.moved_point]
+            moved_point = int(np.floor(self.moved_point/2)*3)
+            self.moved_point = moved_point
+            self.line_verts[moved_point] = self.new_point
+            self.set_linewidth()
+
+def get_profile(dataset, line):
+    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])
+        profile = scipy.ndimage.map_coordinates(np.array(dataset), [xv,yv])
+        
+        profile_dataset = sidpy.Dataset.from_array(profile.sum(axis=0))
+        profile_dataset.data_type='spectrum'
+        profile_dataset.units = dataset.units
+        profile_dataset.quantity = dataset.quantity
+        profile_dataset.set_dimension(0, sidpy.Dimension(np.linspace(xv[0,0], xv[-1,-1], profile_dataset.shape[0]), 
+                                                  name='x', units=dataset.x.units, quantity=dataset.x.quantity,
+                                                  dimension_type='spatial'))
+
+        profile_dataset
+
+    if dataset.data_type.name == 'SPECTRAL_IMAGE':
+        spectral_axis = dataset.get_spectral_dims(return_axis=True)[0]
+        profile = np.zeros([xv.shape[1], 2, len(spectral_axis)])
+        data =np.array(dataset)
+
+        for index_x in range(xv.shape[1]):
+            for  index_y  in range(xv.shape[0]):
+                x = xv[index_y, index_x]
+                y = yv[index_y, index_x]
+                profile[index_x, 0] +=data[int(x),int(y)]
+        profile_dataset = sidpy.Dataset.from_array(profile)
+        profile_dataset.data_type='spectral_image'
+        profile_dataset.units = dataset.units
+        profile_dataset.quantity = dataset.quantity
+        profile_dataset.set_dimension(0, sidpy.Dimension(np.linspace(xv[0,0], xv[-1,-1], profile_dataset.shape[0]), 
+                                                  name='x', units=dataset.x.units, quantity=dataset.x.quantity,
+                                                  dimension_type='spatial'))
+        profile_dataset.set_dimension(1, sidpy.Dimension([0, 1], 
+                                                  name='y', units=dataset.x.units, quantity=dataset.x.quantity,
+                                                  dimension_type='spatial'))
+        
+        profile_dataset.set_dimension(2, spectral_axis)
+    return profile_dataset
+
+
+def get_line_selection_points(line):
+    
+    start_point = line.line_verts[3]
+    right_point = line.line_verts[0]
+    low_point = line.line_verts[2]
+
+    if start_point[0] > right_point[0]:
+        start_point = line.line_verts[0]
+        right_point = line.line_verts[3]
+        low_point = line.line_verts[1]
+    m = (right_point[1] - start_point[1]) / (right_point[0] - start_point[0])
+    length_x = int(abs(start_point[0]-right_point[0]))
+    length_v = int(np.linalg.norm(start_point-right_point))
+    
+    linewidth = int(abs(start_point[1]-low_point[1]))
+    x = np.linspace(0,length_x, length_v)
+    y = np.linspace(0,linewidth, line.line_width)
+    xv, yv = np.meshgrid(x, y)
+    
+    yy = yv +x*m+start_point[1] 
+    xx = (xv.T -y*m ).T + start_point[0]
+    
+    return xx, yy
+
+
+
 def histogram_plot(image_tags):
     """interactive histogram"""
     nbins = 75
@@ -687,10 +816,9 @@ def histogram_plot(image_tags):
     vmax = image_tags['maximum_intensity']
     if 'color_map' not in image_tags:
         image_tags['color_map'] = color_map_list[0]
-    cmap = plt.cm.get_cmap(image_tags['color_map'])
 
+    cmap = plt.cm.get_cmap(image_tags['color_map'])
     colors = cmap(np.linspace(0., 1., nbins))
-
     norm2 = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
     hist, bin_edges = np.histogram(data, np.linspace(vmin, vmax, nbins), density=True)
 
@@ -699,9 +827,7 @@ def histogram_plot(image_tags):
     def onselect(vmin, vmax):
         ax1.clear()
         cmap = plt.cm.get_cmap(image_tags['color_map'])
-
         colors = cmap(np.linspace(0., 1., nbins))
-
         norm2 = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
         hist2, bin_edges2 = np.histogram(data, np.linspace(vmin, vmax, nbins), density=True)
 
@@ -737,7 +863,7 @@ def histogram_plot(image_tags):
             else:
                 vmax = data.max()
                 vmin = data.min()
-        onselect(vmin, vmax)
+            onselect(vmin, vmax)
 
     fig2 = plt.figure()
 
@@ -884,24 +1010,30 @@ def cartesian2polar(x, y, grid, r, t, order=3):
     return ndimage.map_coordinates(grid, np.array([new_ix, new_iy]), order=order).reshape(new_x.shape)
 
 
-def warp(diff, center):
-    """Convert diffraction pattern to polar coordinates"""
+def warp(diff):
+    """Takes a centered diffraction pattern (as a sidpy dataset)and warps it to a polar grid"""
+    """Centered diff can be produced with it.diffractogram_spots(return_center = True)"""
 
     # Define original polar grid
-    nx = diff.shape[0]
-    ny = diff.shape[1]
+    nx = np.shape(diff)[0]
+    ny = np.shape(diff)[1]
 
-    x = np.linspace(1, nx, nx, endpoint=True)-center[1]
-    y = np.linspace(1, ny, ny, endpoint=True)-center[0]
-    z = np.abs(diff)
+    # Define center pixel
+    pix2nm = np.gradient(diff.u.values)[0]
+    center_pixel = [abs(min(diff.u.values)), abs(min(diff.v.values))]//pix2nm
+
+    x = np.linspace(1, nx, nx, endpoint=True)-center_pixel[0]
+    y = np.linspace(1, ny, ny, endpoint=True)-center_pixel[1]
+    z = diff
 
     # Define new polar grid
-    nr = min([center[0], center[1], diff.shape[0]-center[0], diff.shape[1]-center[1]])-1
+    nr = int(min([center_pixel[0], center_pixel[1], diff.shape[0]-center_pixel[0], diff.shape[1]-center_pixel[1]])-1)
     nt = 360*3
 
     r = np.linspace(1, nr, nr)
     t = np.linspace(0., np.pi, nt, endpoint=False)
-    return cartesian2polar(x, y, z, r, t, order=3).T
+
+    return cartesian2polar(x, y, z, r, t, order=3)
 
 
 def calculate_ctf(wavelength, cs, defocus, k):
@@ -957,8 +1089,8 @@ def get_rotation(experiment_spots, crystal_spots):
     
     # get crystal spots of same length and sort them by angle as well
     r_crystal, phi_crystal, crystal_indices = xy2polar(crystal_spots)
-    angle_index = np.argmin(np.abs(r_experiment-r_crystal[1]) )
-    rotation_angle = phi_experiment[angle_index]%(2*np.pi) - phi_crystal[1]
+    angle_index = np.argmin(np.abs(r_experiment-r_crystal[1]))
+    rotation_angle = phi_experiment[angle_index] % (2*np.pi) - phi_crystal[1]
     print(phi_experiment[angle_index])
     st = np.sin(rotation_angle)
     ct = np.cos(rotation_angle)
@@ -967,7 +1099,6 @@ def get_rotation(experiment_spots, crystal_spots):
     return rotation_matrix, rotation_angle
 
 
-
 def calibrate_image_scale(fft_tags, spots_reference, spots_experiment):
     """depreciated get change of scale from comparison of spots to Bragg angles """
     gx = fft_tags['spatial_scale_x']
@@ -989,7 +1120,6 @@ def calibrate_image_scale(fft_tags, spots_reference, spots_experiment):
     return dg
 
 
-
 def align_crystal_reflections(spots, crystals):
     """ Depreciated - use diffraction spots"""