def set_data_test(self, data_shape='3D'):
x = utils.linspace_step(0, 20, 1)
y = utils.linspace_step(0, 30, 1)
t = utils.linspace_step(0, 200, 1)
z = utils.linspace_step(0, 200, 1)
datas = np.zeros((len(y), len(x), len(t), len(z)))
amp = utils.gauss2D(x, 7, 5, y, 12, 10)
for indx in range(len(x)):
for indy in range(len(y)):
datas[indy, indx, :, :] = amp[indy, indx] * (
utils.gauss2D(z, 50 + indx * 2, 20, t, 50 + 3 * indy, 30) + np.random.rand(len(t),
len(z)) / 10)
nav_axis = dict(nav00=Axis(data=y, nav_index=0, label='y_axis', units='yunits'),
nav01=Axis(data=x, nav_index=1, label='x_axis', units='xunits'),
nav02=Axis(data=t, nav_index=2, label='t_axis', units='tunits'),
nav03=Axis(data=z, nav_index=3, label='z_axis', units='zunits'))
if data_shape == '4D':
nav_axes = [2, 3]
self.show_data(datas, temp_data=False, nav_axes=nav_axes, **nav_axis)
elif data_shape == '3D':
self.show_data(np.sum(datas, axis=3), temp_data=False, nav_axes=[0, 1], **nav_axis)
elif data_shape == '2D':
self.show_data(np.sum(datas, axis=(2, 3)), **nav_axis)
elif data_shape == '1D':
self.show_data(np.sum(datas, axis=(1, 2, 3)), **nav_axis)
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 set_Mock_data(self):
"""
| Set the x_axis and y_axis with a linspace distribution from settings parameters.
|
Once done, set the data mock with parameters :
* **Amp** : The amplitude
* **x0** : the origin of x
* **dx** : the derivative x pos
* **y0** : the origin of y
* **dy** : the derivative y pos
* **n** : ???
* **amp_noise** : the noise amplitude
Returns
-------
The computed data mock.
"""
if self.settings.child('ROIselect','use_ROI').value():
x_axis=np.linspace(self.settings.child('ROIselect','x0').value(),self.settings.child('ROIselect','x0').value()+self.settings.child('ROIselect','width').value(),
self.settings.child('ROIselect','width').value(),endpoint=False)
y_axis=np.linspace(self.settings.child('ROIselect','y0').value(),self.settings.child('ROIselect','y0').value()+self.settings.child('ROIselect','height').value(),
self.settings.child('ROIselect','height').value(),endpoint=False)
data_mock=self.settings.child(('Amp')).value()*(mylib.gauss2D(x_axis,self.settings.child(('x0')).value(),self.settings.child(('dx')).value(),
y_axis,self.settings.child(('y0')).value(),self.settings.child(('dy')).value(),self.settings.child(('n')).value()))+self.settings.child(('amp_noise')).value()*np.random.rand(len(y_axis),len(x_axis))
for indy in range(data_mock.shape[0]):
data_mock[indy, :] = data_mock[indy, :] * np.sin(x_axis / 8) ** 2
data_mock = np.roll(data_mock, self.ind_data * self.settings.child(('rolling')).value(), axis=1)
try:
self.image[self.settings.child('ROIselect','y0').value():self.settings.child('ROIselect','y0').value()+self.settings.child('ROIselect','height').value(),
self.settings.child('ROIselect','x0').value():self.settings.child('ROIselect','x0').value()+self.settings.child('ROIselect','width').value()]=data_mock
except Exception as e:
self.emit_status(ThreadCommand('Update_Status',[getLineInfo()+ str(e),'log']))
else:
x_axis=np.linspace(0,self.settings.child(('Nx')).value(),self.settings.child(('Nx')).value(),endpoint=False)
y_axis=np.linspace(0,self.settings.child(('Ny')).value(),self.settings.child(('Ny')).value(),endpoint=False)
data_mock=self.settings.child(('Amp')).value()*(mylib.gauss2D(x_axis,self.settings.child(('x0')).value(),self.settings.child(('dx')).value(),
y_axis,self.settings.child(('y0')).value(),self.settings.child(('dy')).value(),self.settings.child(('n')).value()))+self.settings.child(('amp_noise')).value()*np.random.rand(len(y_axis),len(x_axis))
for indy in range(data_mock.shape[0]):
data_mock[indy,:] = data_mock[indy,:]* np.sin(x_axis / 4) ** 2
data_mock = np.roll(data_mock, self.ind_data * self.settings.child(('rolling')).value(), axis=1)
self.image = data_mock
self.ind_data += 1
QThread.msleep(100)
return self.image
def init_data():
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
data_green = 24 * gauss2D(x, 0.2 * Nx, Nx / 5, y, 0.3 * Ny, Ny / 5, 1, 0)
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))
here = Path(__file__).parent
data_spread = np.load(str(here.joinpath('triangulation_data.npy')))
return data_red, data_green, data_blue, data_spread
def set_2D_Mock_data(self):
self.x_axis = np.linspace(0, 50, 50, endpoint=False)
self.y_axis = np.linspace(0, 30, 30, endpoint=False)
self.data_mock = 10 * gauss2D(self.x_axis, 20, 10, self.y_axis, 15, 7,
1) + 2 * np.random.rand(
len(self.y_axis), len(self.x_axis))
self.data_mock = self.data_mock.astype(
self.settings.child(('data_type')).value())
def random_hypergaussians2D(xy, coeff=1):
x, y = xy
if not hasattr(x, '__len__'):
x = [x]
if not hasattr(y, '__len__'):
y = [y]
signal = np.zeros((len(y), len(x)))
for ind in range(Nstruct):
signal += amp[ind] * utils.gauss2D(x, x0s[ind], coeff * dx[ind], y, y0s[ind], coeff * dy[ind], 2)
signal += 0.1 * np.random.rand(len(y), len(x))
return signal
def set_data_test(self,data_shape='3D'):
x=utils.linspace_step(0,20,1)
y=utils.linspace_step(0,30,1)
t=utils.linspace_step(0,200,1)
z=utils.linspace_step(0,200,1)
datas=np.zeros((len(y),len(x),len(t),len(z)))
amp=utils.gauss2D(x,7,5,y,12,10)
for indx in range(len(x)):
for indy in range(len(y)):
datas[indy,indx,:,:]=amp[indy,indx]*(utils.gauss2D(z,50+indx*2,20,t,50+3*indy,30)+np.random.rand(len(t),len(z))/10)
if data_shape=='4D':
self.show_data(datas,temp_data=False,nav_axes=[2,3])
elif data_shape=='3D':
self.show_data(np.sum(datas,axis=3),temp_data=False,nav_axes=[0,1])
elif data_shape=='2D':
self.show_data(np.sum(datas,axis=(2,3)))
elif data_shape=='1D':
self.show_data(np.sum(datas,axis=(1,2,3)))
def test_gauss2D(self):
x = utils.linspace_step(-1.0, 1, 0.1)
x0 = -0.55
dx = 0.1
y = utils.linspace_step(-2.0, -1, 0.1)
y0 = -1.55
dy = 0.2
n = 1
assert np.all(
utils.gauss2D(x, x0, dx, y, y0, dy, n) == pytest.approx(
np.transpose(
np.outer(utils.gauss1D(x, x0, dx, n),
utils.gauss1D(y, y0, dy, n)))))
assert np.all(
utils.gauss2D(x, x0, dx, y, y0, dy, n) == pytest.approx(
utils.gauss2D(x, x0, dx, y, y0, dy, n, 180)))
assert np.all(
utils.gauss2D(x, x0, dx, y, y0, dy, n, -90) == pytest.approx(
utils.gauss2D(x, x0, dx, y, y0, dy, n, 90)))
assert np.all(
utils.gauss2D(x, x0, dx, y, y0, dy, n) == pytest.approx(
utils.gauss2D(x, x0, dy, y, y0, dx, n, 90)))
def set_Mock_data(self):
"""
| Set the x_axis and y_axis with a linspace distribution from settings parameters.
|
Once done, set the data mock with parameters :
* **Amp** : The amplitude
* **x0** : the origin of x
* **dx** : the derivative x pos
* **y0** : the origin of y
* **dy** : the derivative y pos
* **n** : ???
* **amp_noise** : the noise amplitude
Returns
-------
The computed data mock.
"""
image = np.zeros(
(self.settings.child('spatial_settings', 'Ny').value(),
self.settings.child('spatial_settings', 'Nx').value(),
self.settings.child('temp_settings', 'Nt').value()))
self.time_axis = np.linspace(
0,
self.settings.child('temp_settings', 'Nt').value(),
self.settings.child('temp_settings', 'Nt').value(),
endpoint=False)
if self.settings.child('ROIselect', 'use_ROI').value():
self.x_axis = np.linspace(
self.settings.child('ROIselect', 'x0').value(),
self.settings.child('ROIselect', 'x0').value() +
self.settings.child('ROIselect', 'width').value(),
self.settings.child('ROIselect', 'width').value(),
endpoint=False)
self.y_axis = np.linspace(
self.settings.child('ROIselect', 'y0').value(),
self.settings.child('ROIselect', 'y0').value() +
self.settings.child('ROIselect', 'height').value(),
self.settings.child('ROIselect', 'height').value(),
endpoint=False)
data_mock = self.settings.child(
'spatial_settings', 'amp').value() * (utils.gauss2D(
self.x_axis,
self.settings.child('spatial_settings', 'x0').value(),
self.settings.child('spatial_settings',
'dx').value(), self.y_axis,
self.settings.child('spatial_settings', 'y0').value(),
self.settings.child('spatial_settings', 'dy').value(),
self.settings.child('spatial_settings', 'n').value()
)) + self.settings.child(
('amp_noise')).value() * np.random.rand(
len(self.y_axis), len(self.x_axis))
for indy in range(data_mock.shape[0]):
data_mock[indy, :] = data_mock[indy, :] * np.sin(
self.x_axis / self.settings.child('spatial_settings',
'lambda').value())**2
data_mock = np.roll(data_mock,
self.ind_data *
self.settings.child('rolling').value(),
axis=1)
try:
self.image[
self.settings.child('ROIselect', 'y0').value():
self.settings.child('ROIselect', 'y0').value() + self.settings.child('ROIselect', 'height').value(),
self.settings.child('ROIselect', 'x0').value():
self.settings.child('ROIselect', 'x0').value() + self.settings.child('ROIselect', 'width').value()] \
= data_mock
except Exception as e:
self.emit_status(
ThreadCommand('Update_Status',
[getLineInfo() + str(e), 'log']))
else:
self.x_axis = np.linspace(
0,
self.settings.child('spatial_settings', 'Nx').value(),
self.settings.child('spatial_settings', 'Nx').value(),
endpoint=False)
self.y_axis = np.linspace(
0,
self.settings.child('spatial_settings', 'Ny').value(),
self.settings.child('spatial_settings', 'Ny').value(),
endpoint=False)
data_mock = self.settings.child('spatial_settings', 'amp').value() * (
utils.gauss2D(self.x_axis, self.settings.child('spatial_settings', 'x0').value(),
self.settings.child('spatial_settings', 'dx').value(),
self.y_axis, self.settings.child('spatial_settings', 'y0').value(),
self.settings.child('spatial_settings', 'dy').value(),
self.settings.child('spatial_settings', 'n').value())) + \
self.settings.child(('amp_noise')).value() * \
np.random.rand(len(self.y_axis), len(self.x_axis))
for indy in range(data_mock.shape[0]):
data_mock[indy, :] = data_mock[indy, :] * np.sin(
self.x_axis / self.settings.child('spatial_settings',
'lambda').value())**2
ind = 0
for indy in range(data_mock.shape[0]):
for indx in range(data_mock.shape[1]):
image[indy, indx, :] = data_mock[indy, indx] * \
utils.gauss1D(self.time_axis, self.settings.child('temp_settings', 't0').value(),
self.settings.child('temp_settings', 'dt').value(),
self.settings.child('temp_settings', 'n').value()) * \
np.sin(np.roll(self.time_axis, ind) / 4) ** 2
ind += 1
image = np.roll(image,
self.ind_data * self.settings.child(
('rolling')).value(),
axis=1)
self.image = image
self.ind_data += 1
QThread.msleep(100)
return self.image
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
Form=DockArea()
Form=QtWidgets.QWidget()
prog = Viewer2D(Form);
prog.set_scaling_axes(scaling_options=dict(scaled_xaxis=dict(label="eV",units=None,offset=20,scaling=2),scaled_yaxis=dict(label="time",units='s',offset=-10,scaling=0.1)))
Nx=100;
Ny=200
data_random = pg.np.random.normal(size=(Ny, Nx))
x=pg.np.linspace(0,Nx-1,Nx)
y=pg.np.linspace(0,Ny-1,Ny)
from pymodaq.daq_utils.daq_utils import gauss2D
data_red=data_random+3*gauss2D(x,0.2*Nx,Nx/5,y,0.3*Ny,Ny/5,1)
data_red = pg.gaussianFilter(data_red, (2, 2))
data_green=data_random+3*gauss2D(x,0.6*Nx,Nx/5,y,0.6*Ny,Ny/5,1)
data_green = pg.gaussianFilter(data_green, (2, 2))
data_blue=data_random+3*gauss2D(x,0.7*Nx,Nx/5,y,0.2*Ny,Ny/5,1)
data_blue = pg.gaussianFilter(data_blue, (2, 2))
prog.setImage(data_blue=data_blue,data_green=None,data_red=data_red)
prog.add_ROI('ElipseROI')
#prog.ui.imag_blue.set
#prog.ui.img_blue.setScale(2)
#import hyperspy.api as hs
-------
ind_min : index of the minimum value
min_val : minimum value
"""
ind_min = np.argmax(x, axis=axis)
min_val = np.min(x, axis=axis)
return ind_min, min_val
if __name__ == '__main__':
from pymodaq.daq_utils import daq_utils as utils
import matplotlib.pyplot as plt
x = random_step(00, 100, 5)
y = random_step(00, 100, 5)
g2 = utils.gauss2D(x, 35, 15, y, 55, 20, 1)
(xlin, g2_interp) = linspace_this_image(x, g2, axis=1, Npts=100)
(ylin, g2_interp_both) = linspace_this_image(y, g2_interp, axis=0, Npts=100)
plt.figure('gauss2D')
plt.subplot(221)
plt.pcolormesh(x, y, g2)
plt.subplot(222)
plt.pcolormesh(xlin, y, g2_interp)
plt.subplot(223)
plt.pcolormesh(xlin, ylin, g2_interp_both)
plt.show()
x_c, y_c, M_c = crop_array_to_axis(x, y, g2, [20, 60, 40, 80])
plt.figure('cropped')
plt.subplot(121)
def set_2D_Mock_data(self):
self.x_axis = np.linspace(0, 50, 50, endpoint=False)
self.y_axis = np.linspace(0, 30, 30, endpoint=False)
self.data_mock = 10 * gauss2D(self.x_axis, 20, 10, self.y_axis, 15, 7,
1) + 2 * np.random.rand(
len(self.y_axis), len(self.x_axis))
if __name__ == '__main__':
from pymodaq.QtDesigner_Ressources import QtDesigner_ressources_rc
from pymodaq.daq_utils.gui_utils import DockArea
from pymodaq.daq_utils.daq_utils import ScalingOptions, ScaledAxis, Axis
import sys
import numpy as np
app = QtWidgets.QApplication(sys.argv)
area = DockArea()
win = QtWidgets.QMainWindow()
win.setCentralWidget(area)
viewer = ViewerPointList(area)
Nx = 100
Ny = 200
x = (np.linspace(0, Nx - 1, Nx) + 100) / 2
y = (np.linspace(0, Ny - 1, Ny) - 10) * 2
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)
viewer.setData(data_red)
viewer.setXaxis(Axis(data=x, label='This is x axis', units='au'))
viewer.setYaxis(Axis(data=y, label='This is y axis', units='au'))
win.show()
app.processEvents()
sys.exit(app.exec_())
