def update_crosshair_data(self,posx,posy,name=""): try: (posx_scaled,posy_scaled)=self.scale_axis(posx,posy) self.crosshair_dragged.emit(posx_scaled,posy_scaled) x_axis_scaled,y_axis_scaled=self.scale_axis(self._x_axis,self._y_axis) indx=utils.find_index(self._x_axis,posx)[0][0] indy=utils.find_index(self._y_axis,posy)[0][0] self.crosshairChanged(indx,indy) if self.isdata["blue"]: z_blue=self.image["blue"][indy,indx] self.ui.z_label_blue.setText("{:.6e}".format(z_blue)) if self.isdata["green"]: z_green=self.image["green"][indy,indx] self.ui.z_label_green.setText("{:.6e}".format(z_green)) if self.isdata["red"]: z_red=self.image["red"][indy,indx] self.ui.z_label_red.setText("{:.6e}".format(z_red)) self.ui.x_label.setText("x={:.6e} ".format(posx_scaled)) self.ui.y_label.setText("y={:.6e} ".format(posy_scaled)) except Exception as e: pass
def update_math(self): #self.status_sig.emit(["Update_Status","doing math"]) data_lo=[] for bounds in self.ROI_bounds: indexes=utils.find_index(self._x_axis,bounds) ind1=indexes[0][0] ind2=indexes[1][0] sub_data = self.data[ind1:ind2] sub_xaxis = self._x_axis[ind1:ind2] if self.operation=="Mean": data_lo.append(np.mean(sub_data)) elif self.operation=="Sum": data_lo.append(np.sum(sub_data)) elif self.operation == 'half-life' or self.operation == 'expotime': ind_x0 = utils.find_index(sub_data, np.max(sub_data))[0][0] x0 = sub_xaxis[ind_x0] sub_xaxis = sub_xaxis[ind_x0:] sub_data = sub_data[ind_x0:] offset = sub_data[-1] N0 = np.max(sub_data) - offset if self.operation == 'half-life': time = sub_xaxis[utils.find_index(sub_data - offset, 0.5 * N0)[0][0]]-x0 elif self.operation == 'expotime': time = sub_xaxis[utils.find_index(sub_data - offset, 0.37 * N0)[0][0]] - x0 data_lo.append(time) self.math_sig.emit(data_lo)
def crosshairChanged(self,indx=None,indy=None): if self.image is None or self._x_axis is None or self._y_axis is None: return image = self.image if indx is None or indy is None: (posx,posy)=self.ui.crosshair.get_positions() indx=utils.find_index(self._x_axis,posx)[0][0] indy=utils.find_index(self._y_axis,posy)[0][0] try: if self.isdata["blue"]: self.ui.crosshair_H_blue.setData(y=image["blue"][indy,:], x=self.x_axis_scaled) if self.isdata["green"]: self.ui.crosshair_H_green.setData(y=image["green"][indy,:], x=self.x_axis_scaled) if self.isdata["red"]: self.ui.crosshair_H_red.setData(y=image["red"][indy,:], x=self.x_axis_scaled) if self.isdata["blue"]: self.ui.crosshair_V_blue.setData(y=self.y_axis_scaled, x=image["blue"][:,indx]) if self.isdata["green"]: self.ui.crosshair_V_green.setData(y=self.y_axis_scaled, x=image["green"][:,indx]) if self.isdata["red"]: self.ui.crosshair_V_red.setData(y=self.y_axis_scaled, x=image["red"][:,indx]) except Exception as e: raise e
def _halflife_fun(self, sub_data, axis=None): try: indexes = [ s for s in range(len(sub_data.shape)) if s not in [axis] ] out_shape = tuple(np.array((sub_data.shape))[indexes]) time = np.zeros((np.prod(out_shape))) data_reshaped = sub_data.reshape( (np.prod(out_shape), sub_data.shape[axis])) for ind_dat in range(np.prod(out_shape)): dat = data_reshaped[ind_dat, :] ind_x0 = utils.find_index(dat, np.max(dat))[0][0] sub_xaxis = np.linspace(0, len(dat), len(dat), endpoint=False) x0 = sub_xaxis[ind_x0] sub_xaxis = sub_xaxis[ind_x0:] dat_clipped = dat[ind_x0:] offset = dat_clipped[-1] N0 = np.max(dat_clipped) - offset thalf = sub_xaxis[utils.find_index(dat - offset, 0.5 * N0)[0][0]] - x0 time[ind_dat] = thalf return time.reshape(out_shape) except Exception as e: return time.reshape(out_shape)
def update_viewer_data(self, posx=0, posy=0): """ |PyQt5 slot triggered by the crosshair signal from the 1D or 2D Navigator | Update the viewer informations from an x/y given position and store data. Parameters ---------- posx: (float) from the 1D or 2D Navigator crosshair or from one of the navigation axis viewer (in that case nav_axis tells from wich navigation axis the position comes from) posy: (float) from the 2D Navigator crosshair nav_axis: (int) index of the navigation axis from where posx comes from """ if self.datas is not None: try: nav_axes = self.get_selected_axes() # datas_transposed=self.update_data_signal(self.datas) if len(nav_axes) == 0: data = self.datas.data elif len(nav_axes) == 1: if posx < nav_axes[0]['data'][0] or posx > nav_axes[0]['data'][-1]: return ind_x = utils.find_index(nav_axes[0]['data'], posx)[0][0] data = self.datas.inav[ind_x].data elif len(nav_axes) == 2: if posx < nav_axes[0]['data'][0] or posx > nav_axes[0]['data'][-1]: return if posy < nav_axes[1]['data'][0] or posy > nav_axes[1]['data'][-1]: return ind_x = utils.find_index(nav_axes[0]['data'], posx)[0][0] ind_y = utils.find_index(nav_axes[1]['data'], posy)[0][0] data = self.datas.inav[ind_x, ind_y].data else: pos = [] for ind_view, view in enumerate(self.nav_axes_viewers): p = view.roi_line.getPos()[0] if p < 0 or p > len(nav_axes[ind_view]['data']): return ind = int(np.rint(p)) pos.append(ind) data = self.datas.inav.__getitem__(pos).data if len(self.datas.axes_manager.signal_shape) == 0: # means 0D data, plot on 1D viewer self.data_buffer.extend(data) self.ui.viewer1D.show_data([self.data_buffer]) elif len(self.datas.axes_manager.signal_shape) == 1: # means 1D data, plot on 1D viewer self.ui.viewer1D.remove_plots() self.ui.viewer1D.x_axis = self.x_axis self.ui.viewer1D.show_data([data]) elif len(self.datas.axes_manager.signal_shape) == 2: # means 2D data, plot on 2D viewer self.ui.viewer2D.x_axis = self.x_axis self.ui.viewer2D.y_axis = self.y_axis self.ui.viewer2D.setImage(data) except Exception as e: logger.exception(str(e)) self.update_status(utils.getLineInfo() + str(e), wait_time=self.wait_time, log='log')
def update_viewer_data(self, posx=0, posy=0): """ | Update the viewer informations from an x/y given position and store data. | Ruled by the viewer type (0D,1D,2D) ================ ========= ============================== **Parameters** **Type** **Description** *posx* int the x position of the viewer *posy* int the y position of the viewer ================ ========= ============================== See Also -------- update_status """ try: if self.loaded_data is not None: shape = self.loaded_data scan_type = self.loaded_data_scan_type if scan_type == 'Scan1D': ind_x = utils.find_index(self.nav_x_axis, posx)[0][0] data = self.loaded_data[ind_x] elif scan_type == 'Scan2D': ind_x = utils.find_index(self.nav_x_axis, posx)[0][0] ind_y = utils.find_index(self.nav_y_axis, posy)[0][0] data = self.loaded_data[ind_y, ind_x] if len(data.shape) == 0: # means 0D data, plot on 1D viewer self.data_buffer.append(data) self.ui.viewer1D.show_data([np.array(self.data_buffer)]) elif len(data.shape) == 1: # means 1D data, plot on 1D viewer self.ui.viewer1D.remove_plots() self.ui.viewer1D.x_axis = self.x_axis self.ui.viewer1D.show_data([data]) elif len(data.shape) == 2: # means 2D data, plot on 2D viewer self.ui.viewer2D.set_scaling_axes(scaling_options=edict( scaled_xaxis=edict(label="x axis", units=None, offset=np.min(self.x_axis), scaling=self.x_axis[1] - self.x_axis[0]), scaled_yaxis=edict(label="y axis", units=None, offset=np.min(self.y_axis), scaling=self.y_axis[1] - self.y_axis[0]))) self.ui.viewer2D.setImage(data) except Exception as e: self.update_status(str(e), wait_time=self.wait_time)
def update_viewer_data(self, posx=0, posy=0): """ |PyQt5 slot triggered by the crosshair signal from the 1D or 2D Navigator | Update the viewer informations from an x/y given position and store data. | Ruled by the viewer type (0D,1D,2D) ================ ========= ============================== **Parameters** **Type** **Description** *posx* int the x position of the viewer *posy* int the y position of the viewer ================ ========= ============================== See Also -------- update_status """ try: #datas_transposed=self.update_data_signal(self.datas) if len(self.axes_nav) == 0: data = self.datas.data elif len(self.axes_nav) == 1: ind_x = utils.find_index(self.nav_x_axis['data'], posx)[0][0] data = self.datas.inav[ind_x].data elif len(self.axes_nav) == 2: ind_x = utils.find_index(self.nav_x_axis['data'], posx)[0][0] ind_y = utils.find_index(self.nav_y_axis['data'], posy)[0][0] data = self.datas.inav[ind_x, ind_y].data if len(self.datas.axes_manager.signal_shape ) == 0: #means 0D data, plot on 1D viewer self.data_buffer.extend(data) self.ui.viewer1D.show_data([self.data_buffer]) elif len(self.datas.axes_manager.signal_shape ) == 1: #means 1D data, plot on 1D viewer self.ui.viewer1D.remove_plots() self.ui.viewer1D.x_axis = self.x_axis self.ui.viewer1D.show_data([data]) elif len(self.datas.axes_manager.signal_shape ) == 2: #means 2D data, plot on 2D viewer self.ui.viewer2D.x_axis = self.x_axis self.ui.viewer2D.y_axis = self.y_axis self.ui.viewer2D.setImage(data) except Exception as e: self.update_status(utils.getLineInfo() + str(e), wait_time=self.wait_time)
def update_math(self, measurement_dict): try: if 'datas' in measurement_dict: self.datas = measurement_dict['datas'] if 'ROI_bounds' in measurement_dict: self.ROI_bounds = measurement_dict['ROI_bounds'] if 'x_axis' in measurement_dict: self.x_axis = measurement_dict['x_axis'] if 'operations' in measurement_dict: self.operations = measurement_dict['operations'] if 'channels' in measurement_dict: self.channels = measurement_dict['channels'] # self.status_sig.emit(["Update_Status","doing math"]) data_lo = [] for ind_meas in range(len(self.operations)): indexes = utils.find_index(self.x_axis, self.ROI_bounds[ind_meas]) ind1 = indexes[0][0] ind2 = indexes[1][0] sub_data = self.datas[self.channels[ind_meas]][ind1:ind2] sub_xaxis = self.x_axis[ind1:ind2] if self.operations[ind_meas] == "Mean": data_lo.append(float(np.mean(sub_data))) elif self.operations[ind_meas] == "Sum": data_lo.append(float(np.sum(sub_data))) elif self.operations[ ind_meas] == 'half-life' or self.operations[ ind_meas] == 'expotime': ind_x0 = utils.find_index(sub_data, np.max(sub_data))[0][0] x0 = sub_xaxis[ind_x0] sub_xaxis = sub_xaxis[ind_x0:] sub_data = sub_data[ind_x0:] offset = sub_data[-1] N0 = np.max(sub_data) - offset if self.operations[ind_meas] == 'half-life': time = sub_xaxis[utils.find_index( sub_data - offset, 0.5 * N0)[0][0]] - x0 elif self.operations[ind_meas] == 'expotime': time = sub_xaxis[utils.find_index( sub_data - offset, 0.37 * N0)[0][0]] - x0 data_lo.append(time) return data_lo except Exception as e: logger.exception(str(e)) return []
def get_nav_position(self, posx=0, posy=None): """ crosshair position from the "spread" data viewer. Should return scan index where the scan was closest to posx, posy coordinates Parameters ---------- posx posy See Also -------- update_viewer_data """ nav_axes = self.get_selected_axes() if len(nav_axes) != 0: if 'datas' in nav_axes[0]: datas = nav_axes[0]['datas'] xaxis = datas[0] if len(datas) > 1: yaxis = datas[1] ind_scan = utils.find_common_index(xaxis, yaxis, posx, posy) else: ind_scan = utils.find_index(xaxis, posx)[0] self.ui.navigator1D.ui.crosshair.set_crosshair_position(ind_scan[0])
def test_update_math(self, init_prog_math): prog = init_prog_math datas = np.linspace(np.linspace(1, 10, 10), np.linspace(11, 20, 10), 2) ROI_bounds = [[12, 17], [12, 17], [12, 17], [12, 17]] x_axis = datas[1] operations = ['Mean', 'Sum', 'half-life', 'expotime'] channels = [0, 1, 0, 0] measurement_dict = dict(datas=datas, ROI_bounds=ROI_bounds, x_axis=x_axis, operations=operations, channels=channels) result = prog.update_math(measurement_dict=measurement_dict) sub_data = [] indexes = utils.find_index(x_axis, ROI_bounds[0]) ind1, ind2 = indexes[0][0], indexes[1][0] for ind in range(len(operations)): sub_data.append(datas[channels[ind]][ind1:ind2]) assert result[0] == float(np.mean(sub_data[0])) assert result[1] == float(np.sum(sub_data[1])) assert result[2] == result[3] == 0 assert not prog.update_math(None) prog.update_math(None)
def set_data(self): xlimits = self.viewer1D.ROI.getRegion() indexes = find_index(self.raw_data['xaxis'], xlimits) self.data = self.raw_data['data'][indexes[0][0]:indexes[1][0]] self.xaxis = self.raw_data['xaxis'][indexes[0][0]:indexes[1][0]] try: self.calculate_fft() except: pass self.viewer1D.x_axis = self.xaxis self.update_plot()
def update_crosshair_data(self, posx, posy, name=""): try: indx = utils.find_index(self._x_axis, posx)[0][0] string = "y=" for data in self.datas: string += "{:.6e} / ".format(data[indx]) self.ui.y_label.setText(string) self.ui.x_label.setText("x={:.6e} ".format(posx)) except Exception as e: pass
def do_measurement(self, xmin, xmax, xaxis, data1D, mtype, msubtype): try: boundaries = utils.find_index(xaxis, [xmin, xmax]) sub_xaxis = xaxis[boundaries[0][0]:boundaries[1][0]] sub_data = data1D[boundaries[0][0]:boundaries[1][0]] mtypes = Measurement_type.names() if msubtype in self.subitems: msub_ind = self.subitems.index(msubtype) measurement_results = dict(status=None, value=0, xaxis=np.array([]), datafit=np.array([])) if mtype == 'Cursor_Integration': # "Cursor Intensity Integration": if msubtype == "sum": result_measurement = np.sum(sub_data) elif msubtype == "mean": result_measurement = np.mean(sub_data) elif msubtype == "std": result_measurement = np.std(sub_data) else: result_measurement = 0 elif mtype == 'Max': # "Max": result_measurement = np.max(sub_data) elif mtype == 'Min': # "Min": result_measurement = np.min(sub_data) elif mtype == 'Gaussian_Fit': # "Gaussian Fit": measurement_results['xaxis'] = sub_xaxis offset = np.min(sub_data) amp = np.max(sub_data) - np.min(sub_data) m = utils.my_moment(sub_xaxis, sub_data) p0 = [amp, m[1], m[0], offset] popt, pcov = curve_fit(self.eval_func, sub_xaxis, sub_data, p0=p0) measurement_results['datafit'] = self.eval_func( sub_xaxis, *popt) result_measurement = popt[msub_ind] elif mtype == 'Lorentzian_Fit': # "Lorentzian Fit": measurement_results['xaxis'] = sub_xaxis offset = np.min(sub_data) amp = np.max(sub_data) - np.min(sub_data) m = utils.my_moment(sub_xaxis, sub_data) p0 = [amp, m[1], m[0], offset] popt, pcov = curve_fit(self.eval_func, sub_xaxis, sub_data, p0=p0) measurement_results['datafit'] = self.eval_func( sub_xaxis, *popt) if msub_ind == 4: # amplitude result_measurement = popt[0] * 2 / (np.pi * popt[1] ) # 2*alpha/(pi*gamma) else: result_measurement = popt[msub_ind] elif mtype == 'Exponential_Decay_Fit': # "Exponential Decay Fit": ind_x0 = utils.find_index(sub_data, np.max(sub_data))[0][0] x0 = sub_xaxis[ind_x0] sub_xaxis = sub_xaxis[ind_x0:] sub_data = sub_data[ind_x0:] offset = min([sub_data[0], sub_data[-1]]) measurement_results['xaxis'] = sub_xaxis N0 = np.max(sub_data) - offset t37 = sub_xaxis[utils.find_index(sub_data - offset, 0.37 * N0)[0][0]] - x0 #polynome = np.polyfit(sub_xaxis, -np.log((sub_data - 0.99 * offset) / N0), 1) p0 = [N0, t37, x0, offset] popt, pcov = curve_fit(self.eval_func, sub_xaxis, sub_data, p0=p0) measurement_results['datafit'] = self.eval_func( sub_xaxis, *popt) result_measurement = popt[msub_ind] elif mtype == 'Sinus': # offset = np.mean(sub_data) A = (np.max(sub_data) - np.min(sub_data)) / 2 phi = self.fourierfilt.phase dx = 1 / self.fourierfilt.frequency measurement_results['xaxis'] = sub_xaxis p0 = [A, dx, phi, offset] popt, pcov = curve_fit(self.eval_func, sub_xaxis, sub_data, p0=p0) measurement_results['datafit'] = self.eval_func( sub_xaxis, *popt) result_measurement = popt[msub_ind] # elif mtype=="Custom Formula": # #offset=np.min(sub_data) # #amp=np.max(sub_data)-np.min(sub_data) # #m=utils.my_moment(sub_xaxis,sub_data) # #p0=[amp,m[1],m[0],offset] # popt, pcov = curve_fit(self.custom_func, sub_xaxis, sub_data,p0=[140,750,50,15]) # self.curve_fitting_sig.emit([sub_xaxis,self.gaussian_func(sub_xaxis,*popt)]) # result_measurement=popt[msub_ind] else: result_measurement = 0 measurement_results['value'] = result_measurement return measurement_results except Exception as e: result_measurement = 0 measurement_results['status'] = str(e) return measurement_results
def set_data(self, datas_transposed, temp_data=False, restore_nav_axes=True, **kwargs): """ """ try: if restore_nav_axes: nav_axes = dict([]) for ind, ax in enumerate(self.nav_axes_dicts): nav_axes[f'nav_{ind}'] = ax self.restore_nav_axes(nav_axes) ########################################################################## #display the correct signal viewer if len(datas_transposed.axes_manager.signal_shape) == 0: #signal data are 0D self.ui.viewer1D.parent.setVisible(True) self.ui.viewer2D.parent.setVisible(False) elif len(datas_transposed.axes_manager.signal_shape) == 1: #signal data are 1D self.ui.viewer1D.parent.setVisible(True) self.ui.viewer2D.parent.setVisible(False) elif len(datas_transposed.axes_manager.signal_shape) == 2: #signal data are 2D self.ui.viewer1D.parent.setVisible(False) self.ui.viewer2D.parent.setVisible(True) self.x_axis = Axis() self.y_axis = Axis() if len(datas_transposed.axes_manager.signal_shape) == 1 or len(datas_transposed.axes_manager.signal_shape) == 2:#signal data are 1D if 'x_axis' in kwargs: if not isinstance(kwargs['x_axis'], dict): self.x_axis['data'] = kwargs['x_axis'][:] self.x_axis = kwargs['x_axis'] else: self.x_axis = copy.deepcopy(kwargs['x_axis']) else: self.x_axis['data'] = self.set_axis(datas_transposed.axes_manager.signal_shape[0]) if 'y_axis' in kwargs: self.ui.viewer1D.set_axis_label(axis_settings=dict(orientation='left', label=kwargs['y_axis']['label'], units=kwargs['y_axis']['units'])) if len(datas_transposed.axes_manager.signal_shape)==2:#signal data is 2D if 'y_axis' in kwargs: if not isinstance(kwargs['y_axis'], dict): self.y_axis['data'] = kwargs['y_axis'][:] self.y_axis = kwargs['y_axis'] else: self.y_axis = copy.deepcopy(kwargs['y_axis']) else: self.y_axis['data'] = self.set_axis(datas_transposed.axes_manager.signal_shape[1]) axes_nav = self.get_selected_axes_indexes() if len(axes_nav) == 0 or len(axes_nav) == 1: self.update_viewer_data(*self.ui.navigator1D.ui.crosshair.get_positions()) elif len(axes_nav) == 2: self.update_viewer_data(*self.ui.navigator2D.ui.crosshair.get_positions()) ##get ROI bounds from viewers if any ROI_bounds_1D=[] try: self.ROI1D.getRegion() indexes_values = utils.find_index(self.ui.viewer1D.x_axis, self.ROI1D.getRegion()) ROI_bounds_1D.append(QPointF(indexes_values[0][0], indexes_values[1][0])) except Exception as e: logger.warning(str(e)) ROI_bounds_2D = [] try: ROI_bounds_2D.append(QRectF(self.ROI2D.pos().x(), self.ROI2D.pos().y(), self.ROI2D.size().x(), self.ROI2D.size().y())) except Exception as e: logger.warning(str(e)) ############################################################# # display the correct navigator viewer and set some parameters if len(axes_nav) <= 2: for view in self.nav_axes_viewers: self.ui.nav_axes_widget.layout().removeWidget(view.parent) view.parent.close() self.nav_axes_viewers = [] nav_axes = self.get_selected_axes() if len(nav_axes) == 0: # no Navigator self.ui.navigator1D.parent.setVisible(False) self.ui.navigator2D.parent.setVisible(False) #self.navigator_label.setVisible(False) self.ui.nav_axes_widget.setVisible(False) self.ROI1D.setVisible(False) self.ROI2D.setVisible(False) navigator_data = [] elif len(nav_axes) == 1: # 1D Navigator self.ROI1D.setVisible(True) self.ROI2D.setVisible(True) self.ui.navigator1D.parent.setVisible(True) self.ui.navigator2D.parent.setVisible(False) self.ui.nav_axes_widget.setVisible(False) #self.navigator_label.setVisible(True) self.ui.navigator1D.remove_plots() self.ui.navigator1D.x_axis = nav_axes[0] labels = [] units = [] if self.scan_type.lower() == 'tabular' or self.is_spread: if 'datas' in self.nav_axes_dicts[0]: navigator_data = self.nav_axes_dicts[0]['datas'][:] if 'labels' in self.nav_axes_dicts[0]: labels = self.nav_axes_dicts[0]['labels'][:] if 'all_units' in self.nav_axes_dicts[0]: units = self.nav_axes_dicts[0]['all_units'][:] else: navigator_data = [self.nav_axes_dicts[0]['data']] if self.is_spread: if self.scan_type.lower() == 'tabular': data_spread = [] for ind_label, lab in enumerate(labels): if 'curvilinear' in lab.lower(): data_spread = [self.nav_axes_dicts[0]['datas'][ind]] else: data_spread = self.nav_axes_dicts[0]['datas'][:] data_spread.append(self.get_nav_data(datas_transposed, ROI_bounds_1D, ROI_bounds_2D)[0]) data_spread = np.vstack(data_spread).T else: navigator_data = self.get_nav_data(datas_transposed, ROI_bounds_1D, ROI_bounds_2D) if self.is_spread: self.ui.spread_viewer_2D.parent.setVisible(data_spread.shape[1] == 3) self.ui.spread_viewer_1D.parent.setVisible(data_spread.shape[1] == 2) if data_spread.shape[1] == 3: self.ui.spread_viewer_2D.setImage(data_spread=data_spread) if len(labels) > 1 and len(units) > 1: self.ui.spread_viewer_2D.set_axis_label(dict(orientation='bottom', label=labels[0], units=units[0])) self.ui.spread_viewer_2D.set_axis_label(dict(orientation='left', label=labels[1], units=units[1])) else: ind_sorted = np.argsort(data_spread[:, 0]) self.ui.spread_viewer_1D.show_data([data_spread[:, 1][ind_sorted]], labels=['data'], x_axis=data_spread[:, 0][ind_sorted]) self.ui.spread_viewer_1D.set_axis_label(dict(orientation='bottom', label='Curvilinear value', units='')) if temp_data: self.ui.navigator1D.show_data_temp(navigator_data) self.ui.navigator1D.update_labels(labels) else: self.ui.navigator1D.show_data(navigator_data) self.ui.navigator1D.update_labels(labels) elif len(nav_axes) == 2:#2D Navigator: self.ROI1D.setVisible(True) self.ROI2D.setVisible(True) self.ui.navigator1D.parent.setVisible(False) self.ui.navigator2D.parent.setVisible(True) self.ui.nav_axes_widget.setVisible(False) #self.navigator_label.setVisible(True) self.ui.navigator2D.x_axis = nav_axes[0] self.ui.navigator2D.y_axis = nav_axes[1] navigator_data = self.get_nav_data(datas_transposed, ROI_bounds_1D, ROI_bounds_2D) if temp_data: self.ui.navigator2D.setImageTemp(*navigator_data) else: self.ui.navigator2D.setImage(*navigator_data) else: #more than 2 nv axes, display all nav axes in 1D plots self.ui.navigator1D.parent.setVisible(False) self.ui.navigator2D.parent.setVisible(False) self.ui.nav_axes_widget.setVisible(True) if len(self.nav_axes_viewers) != len(axes_nav): for view in self.nav_axes_viewers: self.ui.nav_axes_widget.layout().removeWidget(view.parent) view.parent.close() widgets = [] self.nav_axes_viewers = [] for ind in range(len(axes_nav)): widgets.append(QtWidgets.QWidget()) self.ui.nav_axes_widget.layout().addWidget(widgets[-1]) self.nav_axes_viewers.append(Viewer1DBasic(widgets[-1], show_line=True)) for ind in range(len(axes_nav)): self.nav_axes_viewers[ind].roi_line_signal.connect(self.update_viewer_data) self.nav_axes_viewers[ind].show_data([nav_axes[ind]['data']]) self.nav_axes_viewers[ind].set_axis_label(dict(orientation='bottom', label=nav_axes[ind]['label'], units=nav_axes[ind]['units'])) self.update_viewer_data() except Exception as e: logger.exception(str(e)) self.update_status(utils.getLineInfo() + str(e), self.wait_time, 'log')
def test_find_index(self): # get closest value and index x = utils.linspace_step(1.0, -1, -0.13) assert utils.find_index(x, -0.55) == [(12, -0.56)] assert utils.find_index(x, [-0.55, 0.741]) == [(12, -0.56), (2, 0.74)] assert utils.find_index(x, 10) == [(0, 1.)]
def set_data(self, datas_transposed, temp_data=False, **kwargs): """ """ try: self.nav_x_axis = dict(data=None, label='', units='') self.nav_y_axis = dict(data=None, label='', units='') if len(self.axes_nav) == 1 or len( self.axes_nav) == 2: #1D Navigator self.nav_y_axis['data'] = [0] if 'nav_x_axis' in kwargs: if not isinstance(kwargs['nav_x_axis'], dict): self.nav_x_axis['data'] = kwargs['nav_x_axis'][:] else: self.nav_x_axis = copy.deepcopy(kwargs['nav_x_axis']) else: self.nav_x_axis['data'] = self.set_axis( datas_transposed.axes_manager.navigation_shape[0]) if len(self.axes_nav) == 2: #2D Navigator: if 'nav_y_axis' in kwargs: if not isinstance(kwargs['nav_y_axis'], dict): self.nav_y_axis['data'] = kwargs['nav_y_axis'][:] else: self.nav_y_axis = copy.deepcopy(kwargs['nav_y_axis']) else: self.nav_y_axis['data'] = self.set_axis( datas_transposed.axes_manager.navigation_shape[1]) ########################################################################## #display the correct signal viewer if len(datas_transposed.axes_manager.signal_shape ) == 0: #signal data are 0D self.ui.viewer1D.parent.setVisible(True) self.ui.viewer2D.parent.setVisible(False) elif len(datas_transposed.axes_manager.signal_shape ) == 1: #signal data are 1D self.ui.viewer1D.parent.setVisible(True) self.ui.viewer2D.parent.setVisible(False) elif len(datas_transposed.axes_manager.signal_shape ) == 2: #signal data are 2D self.ui.viewer1D.parent.setVisible(False) self.ui.viewer2D.parent.setVisible(True) self.x_axis = dict(data=None, label='', units='') self.y_axis = dict(data=None, label='', units='') if len(datas_transposed.axes_manager.signal_shape) == 1 or len( datas_transposed.axes_manager.signal_shape ) == 2: #signal data are 1D if 'x_axis' in kwargs: if not isinstance(kwargs['x_axis'], dict): self.x_axis['data'] = kwargs['x_axis'][:] self.x_axis = kwargs['x_axis'] else: self.x_axis = copy.deepcopy(kwargs['x_axis']) else: self.x_axis['data'] = self.set_axis( datas_transposed.axes_manager.signal_shape[0]) if 'y_axis' in kwargs: self.ui.viewer1D.set_axis_label( axis_settings=dict(orientation='left', label=kwargs['y_axis']['label'], units=kwargs['y_axis']['units'])) if len(datas_transposed.axes_manager.signal_shape ) == 2: #signal data is 2D if 'y_axis' in kwargs: if not isinstance(kwargs['y_axis'], dict): self.y_axis['data'] = kwargs['y_axis'][:] self.y_axis = kwargs['y_axis'] else: self.y_axis = copy.deepcopy(kwargs['y_axis']) else: self.y_axis['data'] = self.set_axis( datas_transposed.axes_manager.signal_shape[1]) if len(self.axes_nav) == 0 or len(self.axes_nav) == 1: self.update_viewer_data( *self.ui.navigator1D.ui.crosshair.get_positions()) elif len(self.axes_nav) == 2: self.update_viewer_data( *self.ui.navigator2D.ui.crosshair.get_positions()) ##get ROI bounds from viewers if any ROI_bounds_1D = [] try: self.ROI1D.getRegion() indexes_values = utils.find_index(self.ui.viewer1D.x_axis, self.ROI1D.getRegion()) ROI_bounds_1D.append( QPointF(indexes_values[0][0], indexes_values[1][0])) except: pass ROI_bounds_2D = [] try: ROI_bounds_2D.append( QRectF(self.ROI2D.pos().x(), self.ROI2D.pos().y(), self.ROI2D.size().x(), self.ROI2D.size().y())) except: pass ############################################################# #display the correct navigator viewer and set some parameters if len(self.axes_nav) == 0: #no Navigator self.ui.navigator1D.parent.setVisible(False) self.ui.navigator2D.parent.setVisible(False) self.navigator_label.setVisible(False) self.ROI1D.setVisible(False) self.ROI2D.setVisible(False) navigator_data = [] elif len(self.axes_nav) == 1: #1D Navigator self.ROI1D.setVisible(True) self.ROI2D.setVisible(True) self.ui.navigator1D.parent.setVisible(True) self.ui.navigator2D.parent.setVisible(False) self.navigator_label.setVisible(True) self.ui.navigator1D.remove_plots() self.ui.navigator1D.x_axis = self.nav_x_axis if len(datas_transposed.axes_manager.signal_shape ) == 0: #signal data are 0D navigator_data = [datas_transposed.data] elif len(datas_transposed.axes_manager.signal_shape ) == 1: #signal data are 1D if ROI_bounds_1D != []: if self.ui.combomath.currentText() == 'Sum': navigator_data = [ datas_transposed.isig[pt.x():pt.y() + 1].sum( (-1)).data for pt in ROI_bounds_1D ] elif self.ui.combomath.currentText() == 'Mean': navigator_data = [ datas_transposed.isig[pt.x():pt.y() + 1].mean( (-1)).data for pt in ROI_bounds_1D ] elif self.ui.combomath.currentText() == 'Half-life': navigator_data = [ datas_transposed.isig[pt.x():pt.y() + 1].halflife((-1)).data for pt in ROI_bounds_1D ] else: if self.ui.combomath.currentText() == 'Sum': navigator_data = [ datas_transposed.isig[:].sum((-1)).data ] elif self.ui.combomath.currentText() == 'Mean': navigator_data = [ datas_transposed.isig[:].mean((-1)).data ] elif self.ui.combomath.currentText() == 'Half-life': navigator_data = [ datas_transposed.isig[:].halflife((-1)).data ] elif len(datas_transposed.axes_manager.signal_shape ) == 2: #signal data is 2D if ROI_bounds_2D != []: navigator_data = [ datas_transposed.isig[rect.x():rect.x() + rect.width(), rect.y():rect.y() + rect.height()].sum( (-1, -2)).data for rect in ROI_bounds_2D ] else: navigator_data = [datas_transposed.sum((-1, -2)).data] else: pass if temp_data: self.ui.navigator1D.show_data_temp(navigator_data) else: self.ui.navigator1D.show_data(navigator_data) elif len(self.axes_nav) == 2: #2D Navigator: self.ROI1D.setVisible(True) self.ROI2D.setVisible(True) self.ui.navigator1D.parent.setVisible(False) self.ui.navigator2D.parent.setVisible(True) self.navigator_label.setVisible(True) self.ui.navigator2D.x_axis = self.nav_x_axis self.ui.navigator2D.y_axis = self.nav_y_axis if len(datas_transposed.axes_manager.signal_shape ) == 0: #signal data is 0D navigator_data = [datas_transposed.data] elif len(datas_transposed.axes_manager.signal_shape ) == 1: #signal data is 1D if ROI_bounds_1D != []: if self.ui.combomath.currentText() == 'Sum': navigator_data = [ datas_transposed.isig[pt.x():pt.y() + 1].sum( (-1)).data for pt in ROI_bounds_1D ] elif self.ui.combomath.currentText() == 'Mean': navigator_data = [ datas_transposed.isig[pt.x():pt.y() + 1].mean( (-1)).data for pt in ROI_bounds_1D ] elif self.ui.combomath.currentText() == 'Half-life': navigator_data = [ datas_transposed.isig[pt.x():pt.y() + 1].halflife((-1)).data for pt in ROI_bounds_1D ] else: if self.ui.combomath.currentText() == 'Sum': navigator_data = [ datas_transposed.isig[:].sum((-1)).data ] elif self.ui.combomath.currentText() == 'Mean': navigator_data = [ datas_transposed.isig[:].mean((-1)).data ] elif self.ui.combomath.currentText() == 'Half-life': navigator_data = [ datas_transposed.isig[:].halflife((-1)).data ] elif len(datas_transposed.axes_manager.signal_shape ) == 2: #signal data is 2D if ROI_bounds_2D != []: navigator_data = [ datas_transposed.isig[rect.x():rect.x() + rect.width(), rect.y():rect.y() + rect.height()].sum( (-1, -2)).data for rect in ROI_bounds_2D ] else: navigator_data = [datas_transposed.sum((-1, -2)).data] else: pass if temp_data: self.ui.navigator2D.setImageTemp(*navigator_data) else: self.ui.navigator2D.setImage(*navigator_data) else: raise Exception('No valid Navigator shape') except Exception as e: self.update_status(utils.getLineInfo() + str(e), self.wait_time, 'log')
def update_measurement(self, xmin, xmax, xaxis, data1D, msub_ind): try: mtype = self.name names = self.names() boundaries = find_index(xaxis, [xmin, xmax]) sub_xaxis = xaxis[boundaries[0][0]:boundaries[1][0]] sub_data = data1D[boundaries[0][0]:boundaries[1][0]] result_measurement = dict(Status=None, datafit=None, xaxis=None) if mtype == names[0]: # Cursor integration: if msub_ind == 0: # sum result_measurement['value'] = np.sum(sub_data) elif msub_ind == 1: # mean result_measurement['value'] = np.mean(sub_data) elif msub_ind == 2: # std result_measurement['value'] = np.std(sub_data) elif mtype == names[1]: # "Max": result_measurement['value'] = np.max(sub_data) elif mtype == names[2]: # "Min": result_measurement['value'] = np.min(sub_data) elif mtype == names[3]: # "Gaussian Fit": offset = np.min(sub_data) amp = np.max(sub_data) - np.min(sub_data) m = my_moment(sub_xaxis, sub_data) p0 = [amp, m[1], m[0], offset] popt, pcov = curve_fit(self.gaussian_func, sub_xaxis, sub_data, p0=p0) result_measurement['xaxis'] = sub_xaxis result_measurement['datafit'] = self.gaussian_func( sub_xaxis, *popt) result_measurement['value'] = popt[msub_ind] elif mtype == names[4]: # "Lorentzian Fit": offset = np.min(sub_data) gamma = 1 amp = np.max(sub_data) - np.min(sub_data) m = my_moment(sub_xaxis, sub_data) p0 = [gamma, amp, m[1], m[0], offset] popt, pcov = curve_fit(self.laurentzian_func, sub_xaxis, sub_data, p0=p0) result_measurement['xaxis'] = sub_xaxis result_measurement['datafit'] = self.laurentzian_func( sub_xaxis, *popt) if msub_ind == 4: # amplitude result_measurement['value'] = popt[0] * 2 / ( np.pi * popt[1]) # 2*alpha/(pi*gamma) else: result_measurement['value'] = popt[msub_ind] elif mtype == names[5]: # "Exponential Decay Fit": offset = min([sub_data[0], sub_data[-1]]) N0 = np.max(sub_data) - offset polynome = np.polyfit(sub_xaxis, -np.log( (sub_data - 0.99 * offset) / N0), 1) p0 = [N0, polynome[0], offset] popt, pcov = curve_fit(self.decaying_func, sub_xaxis, sub_data, p0=p0) self.curve_fitting_sig.emit( [True, sub_xaxis, self.decaying_func(sub_xaxis, *popt)]) result_measurement['xaxis'] = sub_xaxis result_measurement['datafit'] = self.decaying_func( sub_xaxis, *popt) result_measurement['value'] = popt[msub_ind] return (result_measurement) except Exception as e: result_measurement['Status'] = str(e) return result_measurement