def init_prog_show_data(init_prog, distribution='uniform'):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
if distribution == 'uniform':
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green, data_blue])
else:
data = utils.DataFromPlugins(distribution='uniform',
data=[data_spread])
prog.show_data(data)
return prog, qtbot, (data_red, data_green, data_blue, data_spread)
def test_update_display_items(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
QtWidgets.QApplication.processEvents()
data = utils.DataFromPlugins(distribution='spread', data=[data_spread])
prog.show_data(data)
QtWidgets.QApplication.processEvents()
def grab_data(self, Naverage=1, **kwargs):
"""
"""
coeff = self.settings.child(('width_coeff')).value()
fun_type = self.settings.child(('fun_type')).value()
self.datas = np.zeros((self.Ny, self.Nx))
self.stop_flag = False
if self.scan_parameters is not None:
for ind in range(self.scan_parameters.Nsteps):
if self.stop_flag:
break
positions = (self.x_axis[self.scan_parameters.axes_indexes[ind,
0]],
self.y_axis[self.scan_parameters.axes_indexes[ind,
1]])
if fun_type == 'Gaussians':
self.datas[self.scan_parameters.axes_indexes[ind, 1],
self.scan_parameters.axes_indexes[
ind, 0]] = random_hypergaussians2D_signal(
positions, coeff)
else:
self.datas[self.scan_parameters.axes_indexes[ind, 1],
self.scan_parameters.axes_indexes[
ind,
0]] = diverging2D_signal(positions, coeff)
if ind % 100 == 0: # refresh plot every 100 grabed points
self.data_grabed_signal_temp.emit([
utils.DataFromPlugins(
name='MockScanner',
data=[self.datas],
dim='Data2D',
x_axis=utils.Axis(data=self.x_axis),
y_axis=utils.Axis(data=self.y_axis))
])
QtWidgets.QApplication.processEvents()
QThread.msleep(100)
self.data_grabed_signal.emit([
utils.DataFromPlugins(name='MockScanner',
data=[self.datas],
dim='Data2D',
x_axis=utils.Axis(data=self.x_axis),
y_axis=utils.Axis(data=self.y_axis))
])
self.ind_data += 1
def grab_data(self, Naverage=1, **kwargs):
"""
"""
coeff = self.settings.child(('width_coeff')).value()
fun_type = self.settings.child(('fun_type')).value()
if 'positions' in kwargs:
positions = kwargs['positions']
if len(positions) == 2:
if fun_type == 'Gaussians':
data = random_hypergaussians2D_signal(positions, coeff)
else:
data = diverging2D_signal(positions, coeff)
else:
if fun_type == 'Gaussians':
data = random_hypergaussians1D(positions, coeff)[0]
else:
data = diverging1D(positions[0], coeff)
else:
if fun_type == 'Gaussians':
data = random_hypergaussians1D(
np.roll(x_axis1D, -self.ind_data)[0], coeff)
else:
data = diverging1D(np.roll(x_axis1D, -self.ind_data)[0], coeff)
self.data_grabed_signal.emit([
utils.DataFromPlugins(
name='MockAdaptive',
data=[np.array([data])],
dim='Data0D',
)
])
self.ind_data += 1
def ini_detector(self, controller=None):
"""
Initialisation procedure of the detector.
Returns
-------
???
the initialized status.
See Also
--------
set_Mock_data
"""
self.status.update(edict(initialized=False, info="", x_axis=None, y_axis=None, controller=None))
if self.settings.child(('controller_status')).value() == "Slave":
if controller is None:
raise Exception('no controller has been defined externally while this detector is a slave one')
else:
self.controller = controller
else:
self.controller = "Mock controller"
self.emit_status(utils.ThreadCommand('update_main_settings', [['wait_time'],
self.settings.child(('wait_time')).value(),
'value']))
# initialize viewers with the future type of data
self.data_grabed_signal.emit(
[utils.DataFromPlugins(name='Mock1', data=[np.array(0)], dim='Data0D', labels=['RandomGaussians'])])
self.status.initialized = True
self.status.controller = self.controller
return self.status
def test_get_crosshair_lineout_uniform(self, init_prog, position):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
datas = dict(red=data_red, green=data_green)
prog.show_data(data)
QtWidgets.QApplication.processEvents()
XCROSS, YCROSS = position
prog.view.get_action('crosshair').trigger()
QtWidgets.QApplication.processEvents()
with qtbot.waitSignal(
prog.view.lineout_plotter.crosshair_lineout_plotted,
timeout=1000) as blocker:
prog.view.crosshair.set_crosshair_position(XCROSS, YCROSS)
crosshair_dict = blocker.args[0]
for data_key, lineout_data in crosshair_dict.items():
if YCROSS < 0 or YCROSS > datas[data_key].shape[0]:
assert np.any(lineout_data.hor_data == approx(
np.zeros((datas[data_key].shape[1], ))))
else:
assert np.any(lineout_data.hor_data == approx(datas[data_key][
YCROSS, :]))
if XCROSS < 0 or XCROSS > datas[data_key].shape[1]:
assert np.any(lineout_data.ver_data == approx(
np.zeros((datas[data_key].shape[0], ))))
else:
assert np.any(
lineout_data.ver_data == approx(datas[data_key][:,
XCROSS]))
def test_data_from_roi_spread(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='spread', data=[data_spread])
prog.show_data(data)
index_roi, roi, roi_type = create_one_roi(prog,
qtbot,
roitype='RectROI')
roi.setPos((0, 0))
assert prog.view.is_action_checked('roi')
with qtbot.waitSignal(prog.data_to_export_signal,
timeout=1000) as blocker:
roi.setSize((data_red.T).shape)
roi.setPos((0, 0))
data_to_export = blocker.args[0]
assert len(data_to_export['data1D']) != 0
assert len(data_to_export['data0D']) != 0
assert f'{prog.title}_Hlineout_{ROIManager.roi_format(index_roi)}' in data_to_export[
'data1D']
assert f'{prog.title}_Vlineout_{ROIManager.roi_format(index_roi)}' in data_to_export[
'data1D']
assert f'{prog.title}_Integrated_{ROIManager.roi_format(index_roi)}' in data_to_export[
'data0D']
def format_data_as_datafromplugins(data_red=None,
data_green=None,
data_blue=None,
data_spread=None):
if data_spread is None:
distribution = 'uniform'
shape = (0, 0)
for data in [data_red, data_green, data_blue]:
if data is not None:
shape = data.shape
break
data_list = [
data_red if data_red is not None else np.zeros(shape),
data_green if data_green is not None else np.zeros(shape),
data_blue if data_blue is not None else np.zeros(shape),
]
else:
distribution = 'spread'
data_list = [data_spread]
datas = utils.DataFromPlugins(name='',
distribution=distribution,
data=data_list)
return datas
def test_get_crosshair_lineout_spread(self, init_prog, position):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='spread', data=[data_spread])
datas = dict(spread=data_spread)
prog.show_data(data)
QtWidgets.QApplication.processEvents()
red_image_item = prog.view.data_displayer.get_image('red')
XCROSS, YCROSS = position
prog.view.get_action('crosshair').trigger()
QtWidgets.QApplication.processEvents()
with qtbot.waitSignal(
prog.view.lineout_plotter.crosshair_lineout_plotted,
timeout=1000) as blocker:
prog.view.crosshair.set_crosshair_position(XCROSS, YCROSS)
crosshair_dict = blocker.args[0]
data_H_index = slice(None, None, 1)
data_V_index = slice(None, None, 1)
for data_key, lineout_data in crosshair_dict.items():
points, hor_data = red_image_item.get_points_at('y', position[1])
x_sorted_indexes = np.argsort(points[:, 0])
hor_data = hor_data[x_sorted_indexes][data_H_index]
points, ver_data = red_image_item.get_points_at('x', position[0])
x_sorted_indexes = np.argsort(points[:, 1])
ver_data = ver_data[x_sorted_indexes][data_V_index]
assert np.any(lineout_data.hor_data == approx(hor_data))
assert np.any(lineout_data.ver_data == approx(ver_data))
def test_get_image(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
QtWidgets.QApplication.processEvents()
with pytest.raises(KeyError):
prog.view.data_displayer.get_image('not a valid image name')
def test_show_data_spread(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='spread',
data=[data_spread, data_spread])
prog.show_data(data)
assert prog.view.is_action_checked('red')
assert prog.view.is_action_checked('green')
assert not prog.view.is_action_checked('blue')
def main_controller():
app = QtWidgets.QApplication(sys.argv)
form = QtWidgets.QWidget()
Nx = 100
Ny = 200
data_random = np.random.normal(size=(Ny, Nx))
x = np.linspace(0, Nx - 1, Nx)
y = np.linspace(0, Ny - 1, Ny)
from pymodaq.daq_utils.daq_utils import gauss2D
data_red = 3 * gauss2D(x, 0.2 * Nx, Nx / 5, y, 0.3 * Ny, Ny / 5, 1,
90) * np.sin(x / 5)**2 + 0.1 * data_random
# data_red = pg.gaussianFilter(data_red, (2, 2))
data_green = 24 * gauss2D(x, 0.2 * Nx, Nx / 5, y, 0.3 * Ny, Ny / 5, 1, 0)
# data_green = pg.gaussianFilter(data_green, (2, 2))
data_green[70:80, 7:12] = np.nan
data_blue = 10 * gauss2D(x, 0.7 * Nx, Nx / 5, y, 0.2 * Ny, Ny / 5, 1)
data_blue = pg.gaussianFilter(data_blue, (2, 2))
prog = Viewer2D(form)
# prog.set_axis_scaling(scaling_options=utils.ScalingOptions(
# scaled_xaxis=utils.ScaledAxis(label="eV", units=None, offset=100, scaling=0.1),
# scaled_yaxis=utils.ScaledAxis(label="time", units='s', offset=-20, scaling=2)))
form.show()
#prog.auto_levels_action_sym.trigger()
#prog.view.actions['autolevels'].trigger()
data_spread = np.load('../../../resources/triangulation_data.npy')
# data_shuffled = data
# np.random.shuffle(data_shuffled)
# prog.show_data(utils.DataFromPlugins(name='mydata', distribution='spread',
# data=[data, data_shuffled]))
prog.view.get_action('histo').trigger()
prog.view.get_action('autolevels').trigger()
prog.show_data(
utils.DataFromPlugins(name='mydata',
distribution='uniform',
data=[data_red, data_green]))
#prog.show_data(utils.DataFromPlugins(name='mydata', distribution='spread', data=[data_spread]))
#prog.ROI_select_signal.connect(print_roi_select)
#prog.view.get_action('ROIselect').trigger()
#prog.view.ROIselect.setSize((20, 35))
#prog.view.ROIselect.setPos((45, 123))
prog.show_roi_target(True)
prog.move_scale_roi_target((50, 40), (20, 20))
QtWidgets.QApplication.processEvents()
# prog.setImage(data_spread=data)
#app.processEvents()
sys.exit(app.exec_())
def test_isocurve_action(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
prog.view.get_action('isocurve').trigger()
assert prog.view.is_action_checked('isocurve')
assert prog.view.is_action_checked('histo')
def test_histo_connected_to_image(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green, data_blue])
prog.show_data(data)
QtWidgets.QApplication.processEvents()
for color in ['red', 'green', 'blue']:
assert prog.view.histogrammer.get_histogram(color).getLookupTable == \
prog.view.data_displayer.get_image(color).lut
def test_roi_action(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
create_one_roi(prog, qtbot, roitype='RectROI')
assert prog.view.is_action_checked('roi')
assert prog.view.roi_manager.roiwidget.isVisible()
def test_DataFromPlugins(self):
data = [
utils.linspace_step(1, 100, 1),
utils.linspace_step(0.01, 1, 0.01)
]
nav_axes = ["test"]
x_axis = utils.Axis(data=utils.linspace_step(1, 100, 1))
y_axis = utils.Axis(data=utils.linspace_step(1, 100, 1))
data_test = utils.DataFromPlugins(data=data,
nav_axes=nav_axes,
nav_x_axis=x_axis,
nav_y_axis=y_axis)
assert isinstance(data_test, utils.DataFromPlugins)
assert data_test['data'] == data
assert data_test['nav_axes'] == nav_axes
assert data_test['nav_x_axis'] == x_axis
assert data_test['nav_y_axis'] == y_axis
assert data_test['dim'] == 'Data1D'
data = [np.array([1])]
data_test = utils.DataFromPlugins(data=data)
assert data_test['dim'] == 'Data0D'
data = [np.array([[1, 1], [1, 2]])]
data_test = utils.DataFromPlugins(data=data)
assert data_test['dim'] == 'Data2D'
data = [np.array([[[1, 1], [1, 2]], [[2, 1], [2, 2]]])]
data_test = utils.DataFromPlugins(data=data)
assert data_test['dim'] == 'DataND'
with pytest.raises(TypeError):
utils.DataFromPlugins(data=[1, 2, 3, 4, 5])
with pytest.raises(TypeError):
utils.DataFromPlugins(data="str")
def test_show_data_triggers_data_to_export_signal(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
with qtbot.waitSignal(prog.data_to_export_signal,
timeout=1000) as blocker:
prog.show_data(data)
with qtbot.waitSignal(prog.data_to_export_signal,
timeout=1000) as blocker:
prog.show_data(data)
def test_aspect_ratio_action(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
prog.view.get_action('aspect_ratio').trigger()
assert prog.view.is_action_checked('aspect_ratio')
assert prog.view.image_widget.plotitem.vb.state['aspectLocked']
prog.view.get_action('aspect_ratio').trigger()
assert not prog.view.is_action_checked('aspect_ratio')
assert not prog.view.image_widget.plotitem.vb.state['aspectLocked']
def test_histo_action(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
prog.view.get_action('histo').trigger()
assert prog.view.is_action_checked('histo')
assert prog.view.histogrammer.get_histogram('red').isVisible()
assert prog.view.histogrammer.get_histogram('green').isVisible()
assert not prog.view.histogrammer.get_histogram('blue').isVisible()
def test_change_isoline(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
ISOLEVEL = 0.1
prog.view.get_action('isocurve').trigger()
prog.view.isocurver._isoLine.setValue(ISOLEVEL)
prog.view.isocurver._isoLine.sigDragged.emit(
prog.view.isocurver._isoLine)
QtWidgets.QApplication.processEvents()
assert prog.view.isocurver._isocurve_item.level == ISOLEVEL
def test_show_data_uniform(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_blue])
with qtbot.waitSignal(prog.data_to_export_signal,
timeout=1000) as blocker:
prog.show_data(data)
assert prog.view.is_action_checked('red')
assert prog.view.is_action_checked('green')
assert not prog.view.is_action_checked('blue')
assert prog.isdata['red']
assert prog.isdata['green']
assert not prog.isdata['blue']
def test_remove_roi(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
index_roi, roi, roi_type = create_one_roi(prog,
qtbot,
roitype='RectROI')
prog.view.roi_manager.remove_roi_programmatically(index_roi)
QtWidgets.QApplication.processEvents()
assert len(prog.view.lineout_plotter._roi_curves) == 0
def test_update_color_roi(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
index_roi, roi, roi_type = create_one_roi(prog,
qtbot,
roitype='RectROI')
prog.view.roi_manager.settings.child('ROIs',
ROIManager.roi_format(index_roi),
'Color').setValue('b')
roi = prog.view.roi_manager.get_roi_from_index(index_roi)
QtWidgets.QApplication.processEvents()
assert roi.pen == mkPen('b')
def test_FlipLR_action(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
with qtbot.waitSignal(prog._data_to_show_signal,
timeout=1000) as blocker:
prog.view.get_action('flip_lr').trigger()
for ind, data_to_show in enumerate(blocker.args[0]['data']):
assert np.any(data_to_show == approx(np.fliplr(data['data'][ind])))
with qtbot.waitSignal(prog._data_to_show_signal,
timeout=1000) as blocker:
prog.view.get_action('flip_lr').trigger()
for ind, data_to_show in enumerate(blocker.args[0]['data']):
assert np.any(data_to_show == approx(data['data'][ind]))
def test_setpos_crosshair(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
QtWidgets.QApplication.processEvents()
XCROSS = 24
YCROSS = 75
with qtbot.waitSignal(prog.view.get_crosshair_signal(),
timeout=1000) as blocker:
prog.view.get_action('crosshair').trigger()
with qtbot.waitSignal(prog.crosshair_dragged, timeout=1000) as blocker:
prog.view.crosshair.set_crosshair_position(XCROSS, YCROSS)
assert blocker.args[0] == approx(XCROSS)
assert blocker.args[1] == approx(YCROSS)
def test_add_roi(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
index_roi, roi, roi_type = create_one_roi(prog,
qtbot,
roitype='RectROI')
assert roi_type == 'RectROI'
assert index_roi == 0
assert len(prog.view.lineout_plotter.get_roi_curves_triplet()) == 1
index_roi, roi, roi_type = create_one_roi(prog,
qtbot,
roitype='EllipseROI')
assert roi_type == 'EllipseROI'
assert index_roi == 1
assert len(prog.view.lineout_plotter.get_roi_curves_triplet()) == 2
def grab_data(self, Naverage=1, **kwargs):
"""
"""
coeff = self.settings.child(('width_coeff')).value()
fun_type = self.settings.child(('fun_type')).value()
if 'positions' in kwargs:
positions = kwargs['positions']
if len(positions) == 2:
if fun_type == 'Gaussians':
data = random_hypergaussians2D_signal(positions, coeff)
elif fun_type == 'CNRS':
ind_x = max((0, int(min([positions[0], data_CNRS.shape[1]-1]))))
ind_y = max((0, int(min([positions[1], data_CNRS.shape[0] - 1]))))
ind_y = data_CNRS.shape[0] - 1 - ind_y
data = data_CNRS[ind_y, ind_x]
else:
data = diverging2D_signal(positions, coeff)
else:
if fun_type == 'Gaussians':
data = random_hypergaussians1D(positions, coeff)[0]
elif fun_type == 'CNRS':
data = data_CNRS[270, int(positions[0])]
else:
data = diverging1D(positions[0], coeff)
else:
if fun_type == 'Gaussians':
data = random_hypergaussians1D(np.roll(x_axis1D, -self.ind_data)[0], coeff)
else:
data = diverging1D(np.roll(x_axis1D, -self.ind_data)[0], coeff)
data = np.array([data + self.settings['noise'] * np.random.rand()])
self.data_grabed_signal.emit([utils.DataFromPlugins(name='MockAdaptive', data=[data],
dim='Data0D', )])
self.ind_data += 1
def test_crosshair_action(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green])
prog.show_data(data)
assert not prog.view.is_action_visible('position')
prog.view.get_action('crosshair').trigger()
QtWidgets.QApplication.processEvents()
assert prog.view.is_action_checked('crosshair')
assert prog.view.is_action_visible('position')
assert prog.view.crosshair.isVisible()
for image_key in v2d.IMAGE_TYPES:
for curve_key, curve in prog.view.lineout_plotter.get_crosshair_curves_triplet(
)[image_key].items():
assert curve.isVisible()
assert curve == prog.view.lineout_plotter.get_crosshair_curve_triplet(
image_key)[curve_key]
prog.view.get_action('crosshair').trigger()
QtWidgets.QApplication.processEvents()
prog.view.get_action('roi').trigger(
) # will keep lineout_widgets visible so we can check
# if crosshair lineouts are still visible
QtWidgets.QApplication.processEvents()
assert not prog.view.is_action_checked('crosshair')
assert not prog.view.is_action_visible('position')
assert not prog.view.crosshair.isVisible()
for image_key in v2d.IMAGE_TYPES:
for curve in prog.view.lineout_plotter.get_crosshair_curves_triplet(
)[image_key].values():
assert not curve.isVisible()
def test_histo_autolevel_action(self, init_prog):
prog, qtbot = init_prog
data_red, data_green, data_blue, data_spread = init_data()
data = utils.DataFromPlugins(distribution='uniform',
data=[data_red, data_green, data_blue])
prog.show_data(data)
prog.view.get_action('histo').trigger()
assert prog.view.histogrammer.get_histogram(
'red').getLevels() == approx((0, 1.))
assert prog.view.histogrammer.get_histogram(
'green').getLevels() == approx((0, 1.))
assert prog.view.histogrammer.get_histogram(
'blue').getLevels() == approx((0, 1.))
prog.view.get_action('autolevels').trigger()
assert prog.view.histogrammer.get_histogram(
'red').getLevels() == approx((0, 2.9392557954529277))
assert prog.view.histogrammer.get_histogram(
'green').getLevels() == approx((0., 24.0))
assert prog.view.histogrammer.get_histogram('blue').getLevels() ==\
approx((5.693320370703248e-09, 9.83017824174412))
