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

pyTEMlib/image_dialog.py

@@ -14,7 +14,7 @@ try:
     from PyQt5 import QtCore,  QtWidgets
 except:
     Qt_available = False
-    print('Qt dialogs are not available')
+    # print('Qt dialogs are not available')
 
 from matplotlib.widgets import SpanSelector
 from skimage import exposure

pyTEMlib/image_dlg.py

@@ -10,7 +10,7 @@ try:
     from PyQt5 import QtCore, QtGui, QtWidgets
 except:
     Qt_available = False
-    print('Qt dialogs are not available')
+    # print('Qt dialogs are not available')
 
 from matplotlib.figure import Figure
 

pyTEMlib/image_tools.py

@@ -446,9 +446,9 @@ def demon_registration(dataset, verbose=False):
 
 def rigid_registration(dataset):
     """
-    Rigid registration of image stack with sub-pixel accuracy
+    Rigid registration of image stack with pixel accuracy
 
-    Uses phase_cross_correlation from 'skimage.registration'
+    Uses simple cross_correlation
     (we determine drift from one image to next)
 
     Parameters
@@ -461,56 +461,71 @@ def rigid_registration(dataset):
     rigid_registered: sidpy.Dataset
         Registered Stack and drift (with respect to center image)
     """
-
+    
     if not isinstance(dataset, sidpy.Dataset):
         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 = dataset.get_dimensions_by_type(['temporal'])
-    image_dims = dataset.get_dimensions_by_type(['spatial'])
-
-    nopix = dataset.shape[image_dims[0]]
-    nopiy = dataset.shape[image_dims[1]]
+    
+    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')
-
-    data_array = np.moveaxis(np.array(dataset), frame_dim[0], 0)
-
-    fixed = np.array(data_array[0])
-    fft_fixed = np.fft.fft2(fixed)
-
+    
+    fixed = dataset[tuple(selection)].squeeze().compute()
+    fft_fixed =  np.fft.fft2(fixed)
+    
     relative_drift = [[0., 0.]]
-
+    
     for i in trange(nimages):
-        moving = np.array(data_array[i])
+        selection[frame_dim[0]] = slice(i, i+1)
+        moving = dataset[tuple(selection)].squeeze().compute()
         fft_moving = np.fft.fft2(moving)
-        if skimage.__version__[:4] == '0.16':
-            raise DeprecationWarning('Old scikit image version does not work')
-        else:
-            shift = registration.phase_cross_correlation(fft_fixed, fft_moving, upsample_factor=1000, space='fourier')
+        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[0])
-
-    rig_reg, drift = rig_reg_drift(data_array, relative_drift)
+        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 = sidpy.Dataset.from_array(crop_reg)
-    rigid_registered.set_dimension(0, dataset._axes[frame_dim[0]])
-    rigid_registered.set_dimension(1, dataset._axes[image_dims[0]][input_crop[0]:input_crop[1]])
-    rigid_registered.set_dimension(2, dataset._axes[image_dims[1]][input_crop[2]:input_crop[3]])
-    rigid_registered.data_type = 'Image_stack'
-
+    
+    rigid_registered = dataset.like_data(crop_reg)
     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': np.array(dataset.shape)[image_dims]}
-
-    return rigid_registered
-
+                                 '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
@@ -564,7 +579,7 @@ 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(), [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
 
 
@@ -590,7 +605,6 @@ def crop_image_stack(rig_reg, drift):
 
     return rig_reg[:, xpmin:xpmax, ypmin:ypmax], [xpmin, xpmax, ypmin, ypmax]
 
-
 class ImageWithLineProfile:
     """Image with line profile"""
 
@@ -795,6 +809,7 @@ def cart2pol(points):
 
     rho = np.linalg.norm(points[:, 0:2], axis=1)
     phi = np.arctan2(points[:, 1], points[:, 0])
+    
     return rho, phi
 
 
@@ -839,7 +854,7 @@ def xy2polar(points, rounding=1e-3):
 
     r, phi = cart2pol(points)
 
-    phi = phi-phi.min()  # only positive angles
+    phi = phi  # %np.pi # only positive angles
     r = (np.floor(r/rounding))*rounding  # Remove rounding error differences
 
     sorted_indices = np.lexsort((phi, r))  # sort first by r and then by phi
@@ -926,6 +941,33 @@ def calculate_scherzer(wavelength, cs):
     return scherzer
 
 
+def get_rotation(experiment_spots, crystal_spots):
+    """Get rotation by comparing spots in diffractogram to diffraction Bragg spots
+
+    Parameter
+    ---------
+    experiment_spots: numpy array (nx2)
+        positions (in 1/nm) of spots in diffractogram
+    crystal_spots: numpy array (nx2)
+        positions (in 1/nm) of Bragg spots according to kinematic scattering theory
+
+    """
+
+    r_experiment, phi_experiment = cart2pol(experiment_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]
+    print(phi_experiment[angle_index])
+    st = np.sin(rotation_angle)
+    ct = np.cos(rotation_angle)
+    rotation_matrix = np.array([[ct, -st], [st, ct]])
+
+    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']
@@ -947,6 +989,7 @@ def calibrate_image_scale(fft_tags, spots_reference, spots_experiment):
     return dg
 
 
+
 def align_crystal_reflections(spots, crystals):
     """ Depreciated - use diffraction spots"""
 

pyTEMlib/info_dialog.py

@@ -12,17 +12,21 @@ try:
     from PyQt5 import QtCore,  QtWidgets
 except:
     Qt_available = False
-    print('Qt dialogs are not available')
+    # print('Qt dialogs are not available')
+
 
-from pyTEMlib import info_dlg
 import pyTEMlib.eels_dialog_utilities as ieels
 from pyTEMlib.microscope import microscope
-
+import ipywidgets
+import matplotlib.pylab as plt
+import matplotlib
+from IPython.display import display
 from pyTEMlib import file_tools as ft
 _version = 000
 
 
 if Qt_available:
+    from pyTEMlib import info_dlg
     class InfoDialog(QtWidgets.QDialog):
         """
         Input Dialog for EELS Analysis
@@ -40,7 +44,6 @@ if Qt_available:
             self.set_action()
             self.datasets = datasets
 
-            
             self.spec_dim = []
             self.energy_scale = np.array([])
             self.experiment = {}
@@ -55,6 +58,8 @@ if Qt_available:
                 # make a dummy dataset for testing
                 key = 'Channel_000'
                 self.datasets={key: ft.make_dummy_dataset(sidpy.DataType.SPECTRUM)}
+            if key is None:
+                key = list(self.datasets.keys())[0]
             self.dataset = self.datasets[key]
             self.key = key
             if not isinstance(self.dataset, sidpy.Dataset):
@@ -244,21 +249,24 @@ if Qt_available:
                     flux_dataset = self.datasets[key]
                     if flux_dataset.data_type.name == 'IMAGE' or 'SPECTRUM' in flux_dataset.data_type.name:
                         if 'exposure_time' in flux_dataset.metadata['experiment']:
-                            exposure_time = flux_dataset.metadata['experiment']['exposure_time']
+                            if 'number_of_frames' in flux_dataset.metadata['experiment']:
+                                exposure_time = flux_dataset.metadata['experiment']['single_exposure_time'] * flux_dataset.metadata['experiment']['number_of_frames'] 
+                            else:
+                                exposure_time = flux_dataset.metadata['experiment']['exposure_time']
                         else:
-                            exposure_time = 1.0
+                            exposure_time = -1.0
                             flux_dataset.metadata['experiment']['exposure_time'] = -1
                             print('Did not find exposure time assume 1s')
                         if exposure_time > 0:
-                            new_flux  = np.sum(np.array(flux_dataset*1e-6))/exposure_time*exposure_time
+                            new_flux  = np.sum(np.array(flux_dataset*1e-6))/exposure_time*self.dataset.metadata['experiment']['exposure_time']
                             title = flux_dataset.title
                             metadata = flux_dataset.metadata
-            self.experiment['flux_ppm'] = new_flux
-            self.experiment['flux_units'] = 'counts'
-            self.experiment['flux_source'] = title
-            self.experiment['flux_metadata'] = metadata
+                            self.experiment['flux_ppm'] = new_flux
+                            self.experiment['flux_units'] = 'Mcounts '
+                            self.experiment['flux_source'] = title
+                            self.experiment['flux_metadata'] = metadata
     
-            self.update()
+                            self.update()
 
         def on_check(self):
             sender = self.sender()
@@ -290,15 +298,13 @@ if Qt_available:
                 index = self.ui.select_flux.currentIndex()
                 self.ui.statusBar.showMessage('list'+str(index))
                 if index == 1:
-                    ft.add_dataset_from_file(self.datasets, keyname='Reference')
+                    ft.add_dataset_from_file(self.datasets, key_name='Reference')
                     self.set_flux_list()
                 else:
                     key = str(self.ui.select_flux.currentText()).split(':')[0]
                     self.set_flux(key)
                     
                 self.update()
-        
-                
 
         def set_action(self):
             self.ui.statusBar.showMessage('action')
@@ -322,3 +328,338 @@ if Qt_available:
             
             self.ui.binXEdit.editingFinished.connect(self.on_enter)
             self.ui.binYEdit.editingFinished.connect(self.on_enter)
+
+
+def get_sidebar():
+    side_bar = ipywidgets.GridspecLayout(17, 3,width='auto', grid_gap="0px")
+
+    side_bar[0, :2] = ipywidgets.Dropdown(
+            options=[('None', 0)],
+            value=0,
+            description='Main Dataset:',
+            disabled=False)
+    
+    row = 1
+    side_bar[row, :3] = ipywidgets.Button(description='Energy Scale',
+                     layout=ipywidgets.Layout(width='auto', grid_area='header'),
+                     style=ipywidgets.ButtonStyle(button_color='lightblue'))
+    row += 1
+    side_bar[row, :2] = ipywidgets.FloatText(value=7.5,description='Offset:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+    side_bar[row, 2] = ipywidgets.widgets.Label(value="eV", layout=ipywidgets.Layout(width='20px'))
+    row += 1
+    side_bar[row, :2] = ipywidgets.FloatText(value=0.1, description='Dispersion:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+    side_bar[row, 2] = ipywidgets.widgets.Label(value="eV", layout=ipywidgets.Layout(width='20px'))
+    
+    row += 1
+    side_bar[row, :3] = ipywidgets.Button(description='Microscope',
+                     layout=ipywidgets.Layout(width='auto', grid_area='header'),
+                     style=ipywidgets.ButtonStyle(button_color='lightblue'))
+    row += 1
+    side_bar[row, :2] = ipywidgets.FloatText(value=7.5,description='Conv.Angle:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+    side_bar[row, 2] = ipywidgets.widgets.Label(value="mrad", layout=ipywidgets.Layout(width='100px'))
+    row += 1
+    side_bar[row, :2] = ipywidgets.FloatText(value=0.1, description='Coll.Angle:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+    side_bar[row, 2] = ipywidgets.widgets.Label(value="mrad", layout=ipywidgets.Layout(width='100px'))
+    row += 1
+    side_bar[row, :2] = ipywidgets.FloatText(value=0.1, description='Acc Voltage:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+    side_bar[row, 2] = ipywidgets.widgets.Label(value="keV", layout=ipywidgets.Layout(width='100px'))
+    row += 1
+
+    side_bar[row, :3] = ipywidgets.Button(description='Quantification',
+                     layout=ipywidgets.Layout(width='auto', grid_area='header'),
+                     style=ipywidgets.ButtonStyle(button_color='lightblue'))
+    row+=1
+    side_bar[row, :2] = ipywidgets.Dropdown(
+            options=[('None', 0)],
+            value=0,
+            description='Reference:',
+            disabled=False)
+    side_bar[row,2] = ipywidgets.ToggleButton(
+            description='Probability',
+            disabled=False,
+            button_style='', # 'success', 'info', 'warning', 'danger' or ''
+            tooltip='Changes y-axis to probability if flux is given',
+                     layout=ipywidgets.Layout(width='100px'))
+    row += 1
+    side_bar[row, :2] = ipywidgets.FloatText(value=0.1, description='Exp_Time:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+    side_bar[row, 2] = ipywidgets.widgets.Label(value="s", layout=ipywidgets.Layout(width='100px'))
+    row += 1
+    side_bar[row, :2] = ipywidgets.FloatText(value=7.5,description='Flux:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+    side_bar[row, 2] = ipywidgets.widgets.Label(value="Mcounts", layout=ipywidgets.Layout(width='100px'))
+    row += 1
+    side_bar[row, :2] = ipywidgets.FloatText(value=0.1, description='Conversion:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+    side_bar[row, 2] = ipywidgets.widgets.Label(value=r"e$^-$/counts", layout=ipywidgets.Layout(width='100px'))
+    row += 1
+    side_bar[row, :2] = ipywidgets.FloatText(value=0.1, description='Current:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+    side_bar[row, 2] = ipywidgets.widgets.Label(value="pA", layout=ipywidgets.Layout(width='100px') )
+    
+    row += 1
+
+    side_bar[row, :3] = ipywidgets.Button(description='Spectrum Image',
+                     layout=ipywidgets.Layout(width='auto', grid_area='header'),
+                     style=ipywidgets.ButtonStyle(button_color='lightblue'))
+    
+    row += 1
+    side_bar[row, :2] = ipywidgets.IntText(value=1, description='bin X:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+    row += 1
+    side_bar[row, :2] = ipywidgets.IntText(value=1, description='bin X:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+    
+    for i in range(14, 17):
+        side_bar[i, 0].layout.display = "none"
+    return side_bar
+
+
+class SpectrumPlot(sidpy.viz.dataset_viz.CurveVisualizer):
+    def __init__(self, dset, spectrum_number=0, figure=None, **kwargs):
+        with plt.ioff():
+            self.figure = plt.figure()
+        self.figure.canvas.toolbar_position = 'right'
+        self.figure.canvas.toolbar_visible = True
+
+        super().__init__(dset, spectrum_number=spectrum_number, figure=self.figure, **kwargs)
+        
+        self.start_cursor = ipywidgets.FloatText(value=0, description='Start:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+        self.end_cursor = ipywidgets.FloatText(value=0, description='End:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+        self.panel = ipywidgets.VBox([ipywidgets.HBox([ipywidgets.Label('',layout=ipywidgets.Layout(width='100px')), ipywidgets.Label('Cursor:'),
+                                                       self.start_cursor,ipywidgets.Label('eV'), 
+                                                       self.end_cursor, ipywidgets.Label('eV')]),
+                                      self.figure.canvas])
+        
+        self.selector = matplotlib.widgets.SpanSelector(self.axis, self.line_select_callback,
+                                         direction="horizontal",
+                                         interactive=True,
+                                         props=dict(facecolor='blue', alpha=0.2))
+        #self.axis.legend()
+        display(self.panel)
+
+    def line_select_callback(self, x_min, x_max):
+        self.start_cursor.value = np.round(x_min, 3)
+        self.end_cursor.value = np.round(x_max, 3)
+        self.start_channel = np.searchsorted(self.datasets[self.key].energy_loss, self.start_cursor.value)
+        self.end_channel = np.searchsorted(self.datasets[self.key].energy_loss, self.end_cursor.value)
+
+    
+class SIPlot(sidpy.viz.dataset_viz.SpectralImageVisualizer):
+    def __init__(self, dset, figure=None, horizontal=True, **kwargs):
+        if figure is None:
+            with plt.ioff():
+                self.figure = plt.figure()
+        else:
+            self.figure = figure
+        self.figure.canvas.toolbar_position = 'right'
+        self.figure.canvas.toolbar_visible = True
+
+        super().__init__(dset, figure= self.figure, horizontal=horizontal, **kwargs)
+        
+        self.start_cursor = ipywidgets.FloatText(value=0, description='Start:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+        self.end_cursor = ipywidgets.FloatText(value=0, description='End:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+        self.panel = ipywidgets.VBox([ipywidgets.HBox([ipywidgets.Label('',layout=ipywidgets.Layout(width='100px')), ipywidgets.Label('Cursor:'),
+                                                       self.start_cursor,ipywidgets.Label('eV'), 
+                                                       self.end_cursor, ipywidgets.Label('eV')]),
+                                      self.figure.canvas])
+        self.axis = self.axes[-1]
+        self.selector = matplotlib.widgets.SpanSelector(self.axis, self.line_select_callback,
+                                         direction="horizontal",
+                                         interactive=True,
+                                         props=dict(facecolor='blue', alpha=0.2))
+       
+    def line_select_callback(self, x_min, x_max):
+        self.start_cursor.value = np.round(x_min, 3)
+        self.end_cursor.value = np.round(x_max, 3)
+        self.start_channel = np.searchsorted(self.datasets[self.key].energy_loss, self.start_cursor.value)
+        self.end_channel = np.searchsorted(self.datasets[self.key].energy_loss, self.end_cursor.value)
+
+    def _update(self, ev=None):
+
+        xlim = self.axes[1].get_xlim()
+        ylim = self.axes[1].get_ylim()
+        self.axes[1].clear()
+        self.get_spectrum()
+        if len(self.energy_scale)!=self.spectrum.shape[0]:
+            self.spectrum = self.spectrum.T
+        self.axes[1].plot(self.energy_scale, self.spectrum.compute(), label='experiment')
+
+        if self.set_title:
+            self.axes[1].set_title('spectrum {}, {}'.format(self.x, self.y))
+        self.fig.tight_layout()
+        self.selector = matplotlib.widgets.SpanSelector(self.axes[1], self.line_select_callback,
+                                         direction="horizontal",
+                                         interactive=True,
+                                         props=dict(facecolor='blue', alpha=0.2))
+        
+        self.axes[1].set_xlim(xlim)
+        self.axes[1].set_ylim(ylim)
+        self.axes[1].set_xlabel(self.xlabel)
+        self.axes[1].set_ylabel(self.ylabel)
+
+        self.fig.canvas.draw_idle()
+
+class InfoWidget(object):
+    def __init__(self, datasets=None):
+        self.datasets = datasets
+        self.dataset = None
+
+        self.sidebar = get_sidebar()
+        
+        self.set_dataset()
+        self.set_action()
+        
+                                      
+        self.app_layout = ipywidgets.AppLayout(
+            left_sidebar=self.sidebar,
+            center=self.view.panel,
+            footer=None,#message_bar,
+            pane_heights=[0, 10, 0],
+            pane_widths=[4, 10, 0],
+        )
+        
+        display(self.app_layout)
+        
+            
+    def get_spectrum(self):
+        if self.dataset.data_type == sidpy.DataType.SPECTRAL_IMAGE:
+            spectrum = self.dataset.view.get_spectrum()
+            self.axis = self.dataset.view.axes[1]
+        else:
+            spectrum = np.array(self.dataset)
+            self.axis = self.dataset.view.axis
+
+        spectrum *= self.y_scale
+        return spectrum
+
+    def plot(self, scale=True):
+        spectrum = self.get_spectrum()
+        self.energy_scale = self.dataset.energy_loss.values
+        x_limit = self.axis.get_xlim()
+        y_limit = np.array(self.axis.get_ylim())
+        """
+        self.axis.clear()
+
+        self.axis.plot(self.energy_scale, spectrum, label='spectrum')
+                
+        
+        self.axis.set_xlabel(self.datasets[self.key].labels[0])
+        self.axis.set_ylabel(self.datasets[self.key].data_descriptor)
+        self.axis.ticklabel_format(style='sci', scilimits=(-2, 3))
+        if scale:
+            self.axis.set_ylim(np.array(y_limit)*self.change_y_scale)
+        self.change_y_scale = 1.0
+        if self.y_scale != 1.:
+                self.axis.set_ylabel('scattering probability (ppm/eV)')
+        self.selector = matplotlib.widgets.SpanSelector(self.axis, self.line_select_callback,
+                                         direction="horizontal",
+                                         interactive=True,
+                                         props=dict(facecolor='blue', alpha=0.2))
+        self.axis.legend()
+        self.figure.canvas.draw_idle()
+        """
+
+    def set_dataset(self, index=0):
+       
+        spectrum_list = []
+        reference_list =[('None', -1)]
+        dataset_index = self.sidebar[0, 0].value
+        for index, key in enumerate(self.datasets.keys()):
+            if 'Reference' not in key:
+                if 'SPECTR' in self.datasets[key].data_type.name:
+                    spectrum_list.append((f'{key}: {self.datasets[key].title}', index)) 
+            reference_list.append((f'{key}: {self.datasets[key].title}', index))
+       
+        self.sidebar[0,0].options = spectrum_list
+        self.sidebar[9,0].options = reference_list
+        self.key = list(self.datasets)[dataset_index]
+        self.dataset = self.datasets[self.key]
+        if 'SPECTRUM' in self.dataset.data_type.name:
+           for i in range(14, 17):
+                self.sidebar[i, 0].layout.display = "none"
+        else:
+            for i in range(14, 17):
+                self.sidebar[i, 0].layout.display = "flex"
+        #self.sidebar[0,0].value = dataset_index #f'{self.key}: {self.datasets[self.key].title}'
+        self.sidebar[2,0].value = np.round(self.datasets[self.key].energy_loss[0], 3)  
+        self.sidebar[3,0].value = np.round(self.datasets[self.key].energy_loss[1] - self.datasets[self.key].energy_loss[0], 4)  
+        self.sidebar[5,0].value = np.round(self.datasets[self.key].metadata['experiment']['convergence_angle'], 1)  
+        self.sidebar[6,0].value = np.round(self.datasets[self.key].metadata['experiment']['collection_angle'], 1)
+        self.sidebar[7,0].value = np.round(self.datasets[self.key].metadata['experiment']['acceleration_voltage']/1000, 1)
+        self.sidebar[10,0].value = np.round(self.datasets[self.key].metadata['experiment']['exposure_time'], 4)
+        if 'flux_ppm' not in self.datasets[self.key].metadata['experiment']:
+            self.datasets[self.key].metadata['experiment']['flux_ppm'] = 0
+        self.sidebar[11,0].value = self.datasets[self.key].metadata['experiment']['flux_ppm']
+        if 'count_conversion' not in self.datasets[self.key].metadata['experiment']:
+            self.datasets[self.key].metadata['experiment']['count_conversion'] = 1
+        self.sidebar[12,0].value = self.datasets[self.key].metadata['experiment']['count_conversion']
+        if 'beam_current' not in self.datasets[self.key].metadata['experiment']:
+            self.datasets[self.key].metadata['experiment']['beam_current'] = 0
+        self.sidebar[13,0].value = self.datasets[self.key].metadata['experiment']['beam_current']
+        
+        self.view = SIPlot(self.dataset)
+        
+        self.y_scale = 1.0
+        self.change_y_scale = 1.0
+        
+        
+    def cursor2energy_scale(self, value):
+       
+        dispersion = (self.end_cursor.value - self.start_cursor.value) / (self.end_channel - self.start_channel)
+        self.datasets[self.key].energy_loss *= (self.sidebar[3, 0].value/dispersion)
+        self.sidebar[3, 0].value = dispersion
+        offset = self.start_cursor.value - self.start_channel * dispersion
+        self.datasets[self.key].energy_loss += (self.sidebar[2, 0].value-self.datasets[self.key].energy_loss[0])
+        self.sidebar[2, 0].value = offset
+        self.plot()
+        
+    def set_energy_scale(self, value):
+        dispersion = self.datasets[self.key].energy_loss[1] - self.datasets[self.key].energy_loss[0]
+        self.datasets[self.key].energy_loss *= (self.sidebar[3, 0].value/dispersion)
+        self.datasets[self.key].energy_loss += (self.sidebar[2, 0].value-self.datasets[self.key].energy_loss[0])
+        self.plot()
+        
+    def set_y_scale(self, value):  
+        self.change_y_scale = 1/self.y_scale
+        if self.sidebar[9,2].value:
+            dispersion = self.datasets[self.key].energy_loss[1] - self.datasets[self.key].energy_loss[0]
+            self.y_scale = 1/self.datasets[self.key].metadata['experiment']['flux_ppm'] * dispersion
+        else:
+            self.y_scale = 1.0
+            
+        self.change_y_scale *= self.y_scale
+        self.plot()
+        
+    
+    def set_flux(self, value):  
+        self.datasets[self.key].metadata['experiment']['exposure_time'] = self.sidebar[10,0].value
+        if self.sidebar[9,0].value < 0:
+            self.datasets[self.key].metadata['experiment']['flux_ppm'] = 0.
+        else:
+            key = list(self.datasets.keys())[self.sidebar[9,0].value]
+            self.datasets[self.key].metadata['experiment']['flux_ppm'] = (np.array(self.datasets[key])*1e-6).sum() / self.datasets[key].metadata['experiment']['exposure_time']
+            self.datasets[self.key].metadata['experiment']['flux_ppm'] *= self.datasets[self.key].metadata['experiment']['exposure_time']
+        self.sidebar[11,0].value = np.round(self.datasets[self.key].metadata['experiment']['flux_ppm'], 2)
+        
+    def set_microscope_parameter(self, value):
+        self.datasets[self.key].metadata['experiment']['convergence_angle'] = self.sidebar[5,0].value
+        self.datasets[self.key].metadata['experiment']['collection_angle'] = self.sidebar[6,0].value
+        self.datasets[self.key].metadata['experiment']['acceleration_voltage'] = self.sidebar[7,0].value*1000
+    
+    def set_binning(self, value):
+        if 'SPECTRAL' in self.dataset.data_type.name:
+            bin_x = self.sidebar[15,0].value
+            bin_y = self.sidebar[16,0].value
+            self.dataset.view.set_bin([bin_x, bin_y])
+            self.datasets[self.key].metadata['experiment']['SI_bin_x'] = bin_x
+            self.datasets[self.key].metadata['experiment']['SI_bin_y'] = bin_y
+
+    def set_action(self):
+        self.sidebar[0,0].observe(self.set_dataset)
+        self.sidebar[1,0].on_click(self.cursor2energy_scale)
+        self.sidebar[2,0].observe(self.set_energy_scale, names='value')
+        self.sidebar[3,0].observe(self.set_energy_scale, names='value')
+        self.sidebar[5,0].observe(self.set_microscope_parameter)
+        self.sidebar[6,0].observe(self.set_microscope_parameter)
+        self.sidebar[7,0].observe(self.set_microscope_parameter)
+        self.sidebar[9,0].observe(self.set_flux)
+        self.sidebar[9,2].observe(self.set_y_scale)
+        self.sidebar[10,0].observe(self.set_flux)
+        self.sidebar[15,0].observe(self.set_binning)
+        self.sidebar[16,0].observe(self.set_binning)
+        

pyTEMlib/info_dlg.py

@@ -20,7 +20,7 @@ try:
 
 except:
     Qt_available = False
-    print('Qt dialogs are not available')
+    # print('Qt dialogs are not available')
 
 
 if Qt_available: