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
