qcodespp 0.1.3__tar.gz → 0.1.4__tar.gz

{qcodespp-0.1.3 → qcodespp-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qcodespp
-Version: 0.1.3
+Version: 0.1.4
 Summary: Package providing additional functions for QCoDeS
 Maintainer-email: Damon Carrad <damonc@dtu.dk>
 Requires-Python: >=3.10

{qcodespp-0.1.3 → qcodespp-0.1.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = 'flit_core.buildapi'
 
 [project]
 name = "qcodespp"
-version = '0.1.3'
+version = '0.1.4'
 maintainers = [{name = "Damon Carrad", email = "damonc@dtu.dk"}]
 description = "Package providing additional functions for QCoDeS"
 classifiers = [

{qcodespp-0.1.3 → qcodespp-0.1.4}/qcodespp/__init__.py

@@ -65,6 +65,7 @@ from qcodespp.actions import Task, Wait, BreakIf
 
 from qcodespp.plotting.RemotePlot import Plot, live_plot
 from qcodespp.plotting.offline.main import offline_plotting
+from qcodespp.plotting.analysis_tools import colorplot, colored_traces
 
 from qcodespp.data.data_set import new_data, load_data, load_data_num, load_data_nums, set_data_format, set_data_folder
 

{qcodespp-0.1.3 → qcodespp-0.1.4}/qcodespp/plotting/analysis_tools.py

@@ -7,7 +7,8 @@ from matplotlib.ticker import MultipleLocator
 import numpy as np
 
 
-def colorplot(x,y,z,figsize=0,cmap=0,labels=0,xlim=0,ylim=0,zlim=0,xmajor=0,xminor=0,ymajor=0,yminor=0,font_size=0,label_size=0):
+def colorplot(x,y,z,figsize=0,cmap=0,labels=0,xlim=0,ylim=0,zlim=0,xmajor=0,
+              xminor=0,ymajor=0,yminor=0,font_size=0,label_size=0,check_shapes=True):
     """
     Make a nice colourplot from a three-dimensional data array using matplotlib. 
     
@@ -43,6 +44,7 @@ def colorplot(x,y,z,figsize=0,cmap=0,labels=0,xlim=0,ylim=0,zlim=0,xmajor=0,xmin
         
         label_size (int, optional): Font size for the tick labels. Default is 12.
 
+        check_shapes (bool, optional): If True, checks the shapes of x, y, and z arrays and transposes if necessary. Default is True.
 
     Returns:
         tuple: A tuple containing the figure, axis, and colorbar axis objects.
@@ -65,10 +67,11 @@ def colorplot(x,y,z,figsize=0,cmap=0,labels=0,xlim=0,ylim=0,zlim=0,xmajor=0,xmin
     fig, (ax1, cax)=plt.subplots(nrows=1,ncols=2,figsize=figsize,dpi=300,gridspec_kw={'width_ratios':[1,0.02]}) #This allows us better control over the colourbar. Note you can then 'easily' generalise this to more subplots (see below)
     fig.tight_layout(h_pad=None, w_pad=-2)
 
-    if np.shape(z)[1] != np.shape(x)[0] and np.shape(z)[0] == np.shape(x)[0]:
-        z= z.T
-    if np.shape(np.shape(y))==(2,) and np.shape(y)[1] != np.shape(x)[0] and np.shape(y)[0] == np.shape(x)[0]:
-        y= y.T
+    if check_shapes:
+        if np.shape(z)[1] != np.shape(x)[0] and np.shape(z)[0] == np.shape(x)[0]:
+            z= z.T
+        if np.shape(np.shape(y))==(2,) and np.shape(y)[1] != np.shape(x)[0] and np.shape(y)[0] == np.shape(x)[0]:
+            y= y.T
 
     if zlim!=0:
         sdbs=ax1.pcolormesh(x,y,z,cmap=cmap,rasterized=True,linewidth=0,vmin=zlim[0],vmax=zlim[1])

{qcodespp-0.1.3 → qcodespp-0.1.4}/qcodespp/plotting/offline/datatypes.py

@@ -401,7 +401,8 @@ class BaseClassData:
         
     def add_cbar_hist(self):
         self.hax=self.cbar.ax.inset_axes([-1.05, 0, 1, 1],picker=True)
-        counts, self.cbar_hist_bins = np.histogram(self.processed_data[-1],bins=int(self.settings['cmap levels']))
+        counts, self.cbar_hist_bins = np.histogram(self.processed_data[-1],bins=int(self.settings['cmap levels']),
+                                                   range=(np.nanmin(self.processed_data[-1]), np.nanmax(self.processed_data[-1])))
         midpoints = self.cbar_hist_bins[:-1] + np.diff(self.cbar_hist_bins)/2
         self.hax.fill_between(-counts, midpoints,0,color='mediumslateblue')
         self.haxfill=self.hax.fill_betweenx(np.linspace(self.view_settings['Minimum'], self.view_settings['Maximum'], 100), 
@@ -448,7 +449,7 @@ class BaseClassData:
                                                   norm=norm, cmap=cmap,
                                                   rasterized=self.settings['rasterized'])
                 if self.settings['colorbar'] == 'True':
-                    self.cbar = self.figure.colorbar(self.image, orientation='vertical')
+                    self.cbar = self.figure.colorbar(self.image)
                     if self.view_settings['CBarHist'] == True:
                         self.add_cbar_hist()
 
@@ -884,7 +885,7 @@ class MixedInternalData(BaseClassData):
                                                 norm=norm, cmap=cmap,
                                                 rasterized=self.dataset2d.settings['rasterized'])
             if self.dataset2d.settings['colorbar'] == 'True':
-                self.cbar = self.figure.colorbar(self.image, orientation='vertical')
+                self.cbar = self.figure.colorbar(self.image)
                 if self.view_settings['CBarHist'] == True:
                     self.add_cbar_hist()
 
@@ -933,7 +934,9 @@ class MixedInternalData(BaseClassData):
 
     def add_cbar_hist(self):
         self.hax=self.cbar.ax.inset_axes([-1.05, 0, 1, 1],picker=True)
-        counts, self.cbar_hist_bins = np.histogram(self.dataset2d.processed_data[-1],bins=int(self.settings['cmap levels']))
+        counts, self.cbar_hist_bins = np.histogram(self.dataset2d.processed_data[-1],bins=int(self.settings['cmap levels']),
+                                                   range=(np.nanmin(self.dataset2d.processed_data[-1]), 
+                                                          np.nanmax(self.dataset2d.processed_data[-1])))
         midpoints = self.cbar_hist_bins[:-1] + np.diff(self.cbar_hist_bins)/2
         self.hax.fill_between(-counts, midpoints,0,color='mediumslateblue')
         self.haxfill=self.hax.fill_betweenx(np.linspace(self.view_settings['Minimum'], self.view_settings['Maximum'], 100), 

{qcodespp-0.1.3 → qcodespp-0.1.4}/qcodespp/plotting/offline/editor.py

@@ -1024,8 +1024,9 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
     
     def reinstate_markers(self, item, orientation):
         orientations={'horizontal':'horimarkers','vertical':'vertmarkers'}
-        arrayname=orientations[orientation]
-        setattr(item.data,arrayname,[])
+        if orientation != 'diagonal':
+            arrayname=orientations[orientation]
+            setattr(item.data,arrayname,[])
         if orientation == 'horizontal':
             for line in item.data.linecuts['horizontal']['lines']:
                 z=item.data.linecuts[orientation]['lines'][line]['cut_axis_value']
@@ -1041,6 +1042,14 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
                     color=item.data.linecuts[orientation]['lines'][line]['linecolor']))
                 item.data.vertmarkers.append(item.data.axes.axvline(x=z, linestyle='dashed', linewidth=1, ymin=0.9,
                     color=item.data.linecuts[orientation]['lines'][line]['linecolor']))
+                
+        elif orientation == 'diagonal':
+            for line in item.data.linecuts[orientation]['lines']:
+                points0= item.data.linecuts[orientation]['lines'][line]['points'][0]
+                points1= item.data.linecuts[orientation]['lines'][line]['points'][1]
+                item.data.linecuts[orientation]['lines'][line]['draggable_points']=[DraggablePoint(item.data, points0[0], points0[1],
+                                                                                            line,orientation),
+                                            DraggablePoint(item.data, points1[0], points1[1],line,orientation,draw_line=True)]
     
     def clear_sidebar1D(self):
         # clear the sidebar1D
@@ -1074,7 +1083,7 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
                     item.data.axes = item.data.figure.add_subplot(rows, cols, index+1)
                     item.data.add_plot(editor_window=self)
                     if hasattr(item.data, 'linecuts'):
-                        for orientation in ['horizontal','vertical']:#,'diagonal']:#,'circular']:
+                        for orientation in ['horizontal', 'vertical', 'diagonal']:
                             if len(item.data.linecuts[orientation]['lines']) > 0:
                                 self.reinstate_markers(item,orientation)
                             if item.data.linecuts[orientation]['linecut_window'] is not None and item==self.file_list.currentItem():
@@ -1474,7 +1483,7 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
             else:
                 item.data.filters = filters
 
-        else: # A filter is being appended
+        else: # A filter is being appended to the table
             if isinstance(item.data,MixedInternalData) and self.mixeddata_filter_box.currentIndex() == 0:
                 item.data.dataset2d.filters.append(filt)
             elif hasattr(item.data, 'sidebar1D'):
@@ -1485,6 +1494,9 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
                     filt.method_list.remove('Z')
                     if hasattr(filt, 'method') and filt.method == 'Z':
                         filt.method=filt.method_list[0]
+                elif filt.name == 'Sort':
+                    filt.method_list = ['']
+                    filt.method= ''
                 if isinstance(item.data,MixedInternalData):
                     item.data.dataset1d.plotted_lines[current_line]['filters'].append(filt)
                 else:
@@ -2177,6 +2189,10 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
             method_box.setCurrentIndex(filt.method_list.index(filt.method))
             setting_1 = QtWidgets.QTableWidgetItem(filt.settings[0])
             setting_2 = QtWidgets.QTableWidgetItem(filt.settings[1])
+            if hasattr(filt, 'tooltips'):
+                setting_1.setToolTip(filt.tooltips[0])
+                if len(filt.tooltips) > 1:
+                    setting_2.setToolTip(filt.tooltips[1])
             method_box.currentIndexChanged.connect(lambda: self.filters_table_edited(setting_1))
             self.filters_table.setItem(row, 0, filter_item)
             self.filters_table.setCellWidget(row, 1, method_box)
@@ -2219,13 +2235,12 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
             if ((row > 0 and to == -1) or
                 (row < self.filters_table.rowCount()-1 and to == 1)):
                 filters[row], filters[row+to] = filters[row+to], filters[row]
-                self.show_current_filters()
-                self.filters_table.setCurrentCell(row+to, 0)
                 if (self.filters_table.item(row,0).checkState() and 
                     self.filters_table.item(row+to,0).checkState()):
-                    current_item.data.apply_all_filters()
                     self.update_plots(update_color_limits=True)
-                    self.show_current_view_settings()
+                else:
+                    self.show_current_filters()
+                self.filters_table.setCurrentCell(row+to, 0)
 
     def save_image(self):
         current_item = self.file_list.currentItem()

{qcodespp-0.1.3 → qcodespp-0.1.4}/qcodespp/plotting/offline/filters.py

@@ -7,7 +7,9 @@ Created on Thu Nov 9 20:05:23 2017
 
 import numpy as np
 from scipy import ndimage, signal
-from scipy.interpolate import interp1d, interp2d
+from scipy.interpolate import LinearNDInterpolator, CloughTocher2DInterpolator, make_interp_spline
+
+from qcodespp.plotting.analysis_tools import sort_lists
 
 
 # Filter definitions
@@ -15,16 +17,16 @@ from scipy.interpolate import interp1d, interp2d
 def derivative(data, method, times_x, times_y):
     times_x, times_y = int(times_x), int(times_y)
     if len(data) == 3:
-        for _ in range(times_x):
-            data[-1] = np.gradient(data[-1], data[0][:,0], axis=0)
         for _ in range(times_y):
-            data[-1] = np.gradient(data[-1], data[1][0,:], axis=1)
+            data[-1]= np.array([np.gradient(data[-1][i,:], data[1][i,:]) for i in range(data[-1].shape[0])])
+        for _ in range(times_x):
+            data[-1]= np.array([np.gradient(data[-1][:,i], data[0][:,i]) for i in range(data[-1].shape[1])]).T
     elif len(data) == 2:
         for _ in range(times_y):
-            data[-1] = np.gradient(data[-1], data[0])        
+            data[-1] = np.gradient(data[-1], data[0])
     return data
 
-def integrate(data, method, times_x, times_y):
+def cumulative_sum(data, method, times_x, times_y):
     times_x, times_y = int(times_x), int(times_y)
     if len(data) == 3:
         if method=='Z':
@@ -46,7 +48,53 @@ def integrate(data, method, times_x, times_y):
             for _ in range(times_x):
                 data[0] = np.cumsum(data[0])
     
-    return data    
+    return data
+
+def integrate_rectangle(x, y):
+    """
+    Numerically integrate y with respect to x. Should be the same as cumulative sum for regularly spaced x.
+    """
+    integrated_y = np.zeros_like(y)
+    for i in range(1, len(y)):
+        integrated_y[i] = integrated_y[i-1] + y[i] * (x[i] - x[i-1])
+    return integrated_y
+
+def integrate_trapezoid(x,y):
+    """
+    Numerically integrate y with respect to x using the trapezoidal rule.
+    """
+    integrated_y = np.zeros_like(y)
+    for i in range(1,len(y)):
+        integrated_y[i] = integrated_y[i-1] + (y[i] + y[i-1]) * (x[i] - x[i-1]) / 2.0
+    return integrated_y
+
+def integrate_simpson(x, y):
+    """
+    Numerically integrate y with respect to x using Simpson's rule.
+    """
+    integrated_y = np.zeros_like(y)
+    for i in range(1,len(y) - 1):
+        integrated_y[i] = integrated_y[i-1] + (y[i-1] + 4 * y[i] + y[i+1]) * (x[i+1] - x[i-1])/6
+    # Use trapezoidal rule for the last segment
+    integrated_y[-1] = integrated_y[-2] + (y[-1] + y[-2]) * (x[-1] - x[-2]) / 2.0
+    
+    return integrated_y
+
+
+def integrate(data, method, times_x, times_y):
+    times_x, times_y = int(times_x), int(times_y)
+    functions={'Trapezoid': integrate_trapezoid, 'Simpson': integrate_simpson, 'Rectangle': integrate_rectangle}
+    if len(data) == 3:
+        for _ in range(times_x):
+            data[-1] = np.array([functions[method](data[-1][:,i], data[0][:,i]) for i in range(data[-1].shape[1])]).T
+        for _ in range(times_y):
+            data[-1] = np.array([functions[method](data[-1][i,:], data[1][i,:]) for i in range(data[-1].shape[0])])
+
+    elif len(data) == 2:
+        for _ in range(times_y):
+            data[-1] = functions[method](data[0], data[1])
+
+    return data
         
 def smooth(data, method, width_x, width_y):
     filters = {'Gauss': ndimage.gaussian_filter, 
@@ -163,7 +211,10 @@ def cut_y(data, method, bottom, width):
     return data 
 
 def swap_xy(data, method, setting1, setting2):
-    data[0], data[1] = data[1], data[0]
+    if len(data) == 3:
+        data[0], data[1], data[-1] = data[1].T, data[0].T, data[-1].T
+    elif len(data) == 2:
+        data[0], data[1] = data[1], data[0]
     return data
 
 def flip(data, method, setting1, setting2):
@@ -388,23 +439,51 @@ def root(data, method, setting1, setting2):
                 data[axis[method]][j] = np.abs(data[axis[method]][j])**(1/float(setting1))
     return data
 
+def interp2d(x, y, z, kind='linear'):
+    """
+    Re-do the job that scipy used to do
+    """
+    if kind == 'linear':
+        interpolator = LinearNDInterpolator(list(zip(x,y)), z)
+    elif kind == 'cubic':
+        interpolator = CloughTocher2DInterpolator(list(zip(x,y)), z)
+    return interpolator
+
 def interpolate(data, method, n_x, n_y):
+    n_x, n_y = int(n_x), int(n_y)
     if len(data) == 3:
-        x, y = data[0][:,0], data[1][0,:]
-        f_z = interp2d(y, x, data[2], kind=method)
-        n_x, n_y = int(n_x), int(n_y)
-        min_x, max_x = np.amin(data[0]), np.amax(data[0]) 
-        min_y, max_y = np.amin(data[1]), np.amax(data[1])
-        yp, xp = np.linspace(min_y, max_y, n_y), np.linspace(min_x, max_x, n_x)
-        data[1], data[0] = np.meshgrid(yp, xp)
-        data[2] = f_z(yp, xp)
+        x=data[0].flatten()
+        y=data[1].flatten()
+        z=data[2].flatten()
+        f_z = interp2d(x,y,z, kind=method)
+        X, Y = np.linspace(min(x), max(x), n_x), np.linspace(min(y), max(y), n_y)
+        X, Y = np.meshgrid(X, Y)
+        data[2] = np.ma.masked_invalid(f_z(X,Y).T)
+        data[0] = X.T
+        data[1] = Y.T
     elif len(data) == 2:
-        f = interp1d(data[0], data[1], kind=method)
-        n_x = int(n_x)
-        min_x, max_x = np.amin(data[0]), np.amax(data[0]) 
-        data[0] = np.linspace(min_x, max_x, n_x)
+        kind={'linear': 1, 'cubic': 3}
+        x,y=sort_lists(data[0], data[1])
+        f = make_interp_spline(x, y, kind[method])
+        data[0] = np.linspace(np.min(x), np.max(x), n_x)
         data[1] = f(data[0])
     return data
+
+def sort(data, method, setting1, setting2):
+    if len(data) == 3:
+        if method == 'X':
+            xsort,zsort=np.zeros_like(data[-1]),np.zeros_like(data[-1])
+            for i in range(data[-1].shape[1]):
+                xsort[:,i],zsort[:,i]=sort_lists(data[0][:,i],data[-1][:,i])
+            data=[xsort, data[1], zsort]
+        elif method == 'Y':
+            ysort,zsort=np.zeros_like(data[-1]),np.zeros_like(data[-1])
+            for i in range(data[-1].shape[0]):
+                ysort[i,:],zsort[i,:]=sort_lists(data[1][i],data[-1][i])
+            data=[data[0], ysort, zsort]
+    elif len(data) == 2:
+        data[0], data[1] = sort_lists(data[0], data[1])
+    return data
     
 def add_slope(data, method, a_x, a_y):
     if len(data) == 3:
@@ -431,36 +510,49 @@ def invert(data, method, setting1, setting2):
         
         
 class Filter:   
-    DEFAULT_SETTINGS = {'Derivative': {'Method': ['Mid'],
+    DEFAULT_SETTINGS = {'Derivative': {'Method': [''],
                                        'Settings': ['0', '1'],
+                                       'tooltips': ['Order in X', 'Order in Y'],
                                        'Function': derivative,
                                        'Checkstate': 2},
-                        'Integrate': {'Method': ['Z','Y','X'],
+                        'Integrate': {'Method': ['Trapezoid','Simpson','Rectangle'],
                                        'Settings': ['0', '1'],
+                                       'tooltips': ['Order in X', 'Order in Y'],
                                        'Function': integrate,
                                        'Checkstate': 2},
+                        'Cumulative sum': {'Method': ['Z','Y','X'],
+                                       'Settings': ['0', '1'],
+                                       'tooltips': ['Order in zero-th index', 'Order in first index'],
+                                        'Function': cumulative_sum,
+                                        'Checkstate': 2},
                         'Smoothen': {'Method': ['Gauss', 'Median'],
                                      'Settings': ['0', '2'],
+                                     'tooltips': ['Smoothing window in X', 'Smoothing window in Y'],
                                      'Function': smooth,
                                      'Checkstate': 2},
                         'Savitzy-Golay smoothing': {'Method': ['Y','X','dY','dX','ddY','ddX'],
                                     'Settings': ['7', '2'],
+                                    'tooltips': ['Smoothing window', 'Polynomial order'],
                                     'Function': sav_gol,
-                                    'Checkstate': 2},                               
+                                    'Checkstate': 2},
                         'Add/Subtract': {'Method': ['X','Y','Z'],
                                    'Settings': ['0', ''],
+                                   'tooltips': ['Value'],
                                    'Function': offset,
                                    'Checkstate': 2},
                         'Multiply': {'Method': ['X','Y','Z'],
                                      'Settings': ['1', ''],
+                                     'tooltips': ['Value'],
                                      'Function': multiply,
                                      'Checkstate': 2}, 
                         'Divide': {'Method': ['X','Y','Z'],
                                    'Settings': ['1', ''],
+                                   'tooltips': ['Value'],
                                    'Function': divide,
                                    'Checkstate': 0},
                         'Add Slope': {'Method': [''],
                                   'Settings': ['0', '-1'],
+                                  'tooltips': ['Slope value in X', 'Slope value in Y'],
                                   'Function': add_slope,
                                   'Checkstate': 2},
                         'Invert': {'Method': ['X','Y','Z'],
@@ -469,6 +561,7 @@ class Filter:
                                    'Checkstate': 0},
                         'Normalize': {'Method': ['Max', 'Min', 'Min to Max','Point'],
                                       'Settings': ['', ''],
+                                      'tooltips': ['X coordinate', 'Y coordinate'],
                                       'Function': normalize,
                                       'Checkstate': 2},
                         'Subtract average': {'Method': ['Z', 'Y', 'X'],
@@ -476,7 +569,8 @@ class Filter:
                                         'Function': subtract_average,
                                         'Checkstate': 2},
                         'Offset line by line': {'Method': ['Z', 'Y'],
-                                      'Settings': ['', ''],
+                                      'Settings': ['0', ''],
+                                      'tooltips': ['Index'],
                                       'Function': offset_line_by_line,
                                       'Checkstate': 2},
                         'Subtract average line by line': {'Method': ['Z', 'Y'],
@@ -485,18 +579,22 @@ class Filter:
                                         'Checkstate': 2},
                         'Subtract trace': {'Method': ['Ver', 'Hor'],
                                      'Settings': ['0', ''],
+                                     'tooltips': ['Index'],
                                      'Function': subtract_trace,
                                      'Checkstate': 0},
                         'Logarithm': {'Method': ['Mask','Shift','Abs'],
                                       'Settings': ['10', ''],
+                                      'tooltips': ['Base; 10, 2 or e'],
                                       'Function': logarithm,
                                       'Checkstate': 2}, 
                         'Power': {'Method': ['X','Y','Z'],
                                  'Settings': ['2', ''],
+                                 'tooltips': ['Exponent'],
                                  'Function': power,
                                  'Checkstate': 2}, 
                         'Root': {'Method': ['X','Y','Z'],
                                  'Settings': ['2', ''],
+                                 'tooltips': ['Exponent'],
                                  'Function': root,
                                  'Checkstate': 2}, 
                         'Absolute': {'Method': [''],
@@ -507,32 +605,43 @@ class Filter:
                                  'Settings': ['', ''],
                                  'Function': flip,
                                  'Checkstate': 2}, 
-                        'Interp': {'Method': ['linear','cubic','quintic'],
+                        'Interpolate': {'Method': ['linear','cubic'],
                                    'Settings': ['800', '600'],
+                                   'tooltips': ['Number of points in X', 'Number of points in Y'],
                                    'Function': interpolate,
                                    'Checkstate': 0},
+                        'Sort': {'Method': ['X','Y'],
+                                   'Settings': ['', ''],
+                                   'Function': sort,
+                                   'Checkstate': 2},
                         'Roll X': {'Method': ['Index'],
                                    'Settings': ['0', '0'],
+                                    'tooltips': ['Position', 'Amount'],
                                    'Function': roll_x,
                                    'Checkstate': 0},                             
                         'Roll Y': {'Method': ['Index'],
                                    'Settings': ['0', '0'],
+                                    'tooltips': ['Position', 'Amount'],
                                    'Function': roll_y,
                                    'Checkstate': 0},
                         'Crop X': {'Method': ['Abs', 'Rel', 'Lim'],
                                    'Settings': ['-1', '1'],
+                                   'tooltips': ['Min', 'Max'],
                                    'Function': crop_x,
                                    'Checkstate': 0},                              
                         'Crop Y': {'Method': ['Abs', 'Rel', 'Lim'],
-                                   'Settings': ['-2', '2'],
+                                   'Settings': ['-1', '1'],
+                                   'tooltips': ['Min', 'Max'],
                                    'Function': crop_y,
                                    'Checkstate': 0},
                         'Cut X': {'Method': ['Index'],
                                   'Settings': ['0', '0'],
+                                    'tooltips': ['Left index', 'Width'],
                                   'Function': cut_x,
                                   'Checkstate': 0},                               
                         'Cut Y': {'Method': ['Index'],
                                   'Settings': ['0', '0'],
+                                    'tooltips': ['Bottom index', 'Width'],
                                   'Function': cut_y,
                                   'Checkstate': 0},                                
                         'Swap X/Y': {'Method': [''],
@@ -541,7 +650,7 @@ class Filter:
                                     'Checkstate': 2}, 
                                    } 
     
-    def __init__(self, name, method=None, settings=None, checkstate=None):
+    def __init__(self, name, method=None, settings=None, checkstate=None, dimension=2):
         self.name = name
         default_settings = self.DEFAULT_SETTINGS.copy()
         self.method_list = default_settings[name]['Method']
@@ -558,4 +667,6 @@ class Filter:
         else:
             self.checkstate = default_settings[name]['Checkstate']
         self.function = default_settings[name]['Function']
+        if 'tooltips' in default_settings[name]:
+            self.tooltips = default_settings[name]['tooltips']
         

qcodespp-0.1.4/qcodespp/version.py

@@ -0,0 +1 @@
+__version__ = '0.1.4'

qcodespp-0.1.3/qcodespp/version.py

@@ -1 +0,0 @@
-__version__ = '0.1.3'