def grab_data(self, Naverage=1, **kwargs): """ | Start new acquisition. | grab the current values. | Send the data_grabed_signal once done. =============== ======== =============================================== **Parameters** **Type** **Description** *Naverage* int Number of values to average =============== ======== =============================================== """ data_tot = [] for channel in self.settings.child('config', 'channels').value()['selected']: if self.settings.child('config', 'separate_viewers').value(): data_tot.append( DataFromPlugins(name=channel, data=[self.query_data(channel + '.')[2]], dim='Data0D')) else: data_tot.append(self.query_data(channel + '.')[2]) if self.settings.child('config', 'separate_viewers').value(): self.data_grabed_signal.emit(data_tot) else: self.data_grabed_signal.emit([ DataFromPlugins(name='Keithley', data=data_tot, dim='Data0D') ])
def grab_data(self, Naverage=1, **kwargs): """ | grab the current values with NIDAQ profile procedure. | | Send the data_grabed_signal once done. =============== ======== =============================================== **Parameters** **Type** **Description** *Naverage* int Number of values to average =============== ======== =============================================== See Also -------- DAQ_NIDAQ_source """ if self.settings.child( ('NIDAQ_type')).value() == DAQ_NIDAQ_source(0).name: #analog input channels = [ child.opts['title'] for child in self.settings.child( 'ai_settings', 'ai_channels').children() ] data_tot = [] read = self.PyDAQmx.int32() N = self.settings.child('ai_settings', 'Nsamples').value() data = np.zeros(N * len(channels), dtype=np.float64) #self.task.StartTask() self.task.ReadAnalogF64(self.PyDAQmx.DAQmx_Val_Auto, 50.0, self.PyDAQmx.DAQmx_Val_GroupByChannel, data, len(data), self.PyDAQmx.byref(read), None) #self.task.StopTask() if self.control_type == "0D": for ind in range(len(channels)): data_tot.append( np.array([np.mean(data[ind * N:(ind + 1) * N])])) self.data_grabed_signal.emit([ DataFromPlugins(name='NI AI', data=data_tot, dim='Data0D', labels=channels) ]) else: for ind in range(len(channels)): data_tot.append(data[ind * N:(ind + 1) * N]) self.data_grabed_signal.emit([ DataFromPlugins(name='NI AI', data=data_tot, dim='Data1D', labels=channels) ]) elif self.settings.child( ('NIDAQ_type' )).value() == DAQ_NIDAQ_source(1).name: #counter input self.task.StartTask() self.timer.start( self.settings.child('counter_settings', 'counting_time').value())
def grab_data(self, Naverage=1, **kwargs): """ | Start new acquisition. | For each data on data_mock : * shift right data of ind_data positions * if naverage parameter is defined append the mean of the current data to the data to be grabbed. | | Send the data_grabed_signal once done. =============== ======== =============================================== **Parameters** **Type** **Description** *Naverage* int specify the threshold of the mean calculation =============== ======== =============================================== """ data_tot = [] for ind, data in enumerate(self.data_mock): data = np.roll(data, self.ind_data) if Naverage > 1: data_tot.append(np.array([np.mean(data[0:Naverage - 1])])) else: data_tot.append(np.array([data[0]])) if self.settings.child(('sep_viewers')).value(): dat = [DataFromPlugins(name=f'Mock_{ind:03}', data=[data], dim='Data0D', labels=[f'mock data {ind:03}']) for ind, data in enumerate(data_tot)] self.data_grabed_signal.emit(dat) else: self.data_grabed_signal.emit([DataFromPlugins(name='Mock1', data=data_tot, dim='Data0D', labels=['dat0', 'data1'])]) self.ind_data += 1
def commit_settings(self, param): """ Activate the parameters changes in the hardware. =============== ================================= ============================ **Parameters** **Type** **Description** *param* instance of pyqtgraph.parameter The parameter to be checked. =============== ================================= ============================ See Also -------- daq_utils.ThreadCommand """ try: if param.name() == 'timeout': self.controller.timeout = self.settings.child( ('timeout')).value() if param.name() == 'load_setup': self.controller.write('RSET{:d};'.format( self.settings.child('config', 'setup', 'setup_number').value())) param.setValue(False) if param.name() == 'save_setup': self.controller.write('SSET{:d};'.format( self.settings.child('config', 'setup', 'setup_number').value())) param.setValue(False) elif param.name() == 'channels': data_init = [] for channel in param.value()['selected']: if self.settings.child('config', 'separate_viewers').value(): data_init.append( DataFromPlugins(name=channel, data=[np.array([0])], dim='Data0D')) else: data_init.append(np.array([0])) if self.settings.child('config', 'separate_viewers').value(): self.data_grabed_signal_temp.emit(data_init) else: self.data_grabed_signal_temp.emit([ DataFromPlugins(name='SR830', data=data_init, dim='Data0D') ]) elif param.name() == 'reset': self.reset() param.setValue(False) except Exception as e: self.emit_status( ThreadCommand('Update_Status', [getLineInfo() + str(e), 'log']))
def emit_data(self): if self.grabbing: with self.controller.fetch_buffer() as buffer: payload = buffer.payload component = payload.components[0] width = component.width height = component.height data_format = component.data_format if self.settings.child('ROIselect', 'use_ROI').value(): offsetx = self.controller.device.node_map.get_node( 'OffsetX').value offsety = self.controller.device.node_map.get_node( 'OffsetY').value else: offsetx = 0 offsety = 0 if data_format in mono_location_formats: data_tmp = component.data.reshape(height, width) self.data[offsety:offsety + height, offsetx:offsetx + width] = data_tmp self.data_grabed_signal.emit([ DataFromPlugins(name='GenICam ', data=[self.data], dim='Data2D'), ]) else: # The image requires you to reshape it to draw it on the canvas: if data_format in rgb_formats or \ data_format in rgba_formats or \ data_format in bgr_formats or \ data_format in bgra_formats: # content = component.data.reshape( height, width, int(component.num_components_per_pixel ) # Set of R, G, B, and Alpha ) # if data_format in bgr_formats: # Swap every R and B: content = content[:, :, ::-1] self.data_grabed_signal.emit([ DataFromPlugins( name='GenICam ', data=[ self.data[:, :, ind] for ind in range( min(3, component.num_components_per_pixel)) ], dim='Data2D'), ]) self.grabbing = False
def init_data(self, Nx=None, Ny=None): #%%%%%% Initialize data: self.data_stem for the memory to store new data and self.data_stem_average to store the average data if not self.settings.child(('do_hyperspectroscopy')).value(): self.SIZEX = Nx self.SIZEY = Ny self.stem_scan.setImageSize(Nx, Ny) self.stem_scan.setImageArea(Nx, Ny, 0, Nx, 0, Ny) else: Nx = self.settings.child('hyperspectroscopy', 'camera_mode_settings', 'spim_x').value() Ny = self.settings.child('hyperspectroscopy', 'camera_mode_settings', 'spim_y').value() startx = self.settings.child('ROIselect', 'x0').value() starty = self.settings.child('ROIselect', 'y0').value() endx = startx + self.settings.child('ROIselect', 'width').value() endy = starty + self.settings.child('ROIselect', 'height').value() self.SIZEX = Nx self.SIZEY = Ny self.spim_scan.setImageArea(Nx, Ny, startx, endx, starty, endy) self.data_spectrum_spim = [ DataFromPlugins( name='SPIM ', data=[ np.zeros((self.settings.child('hyperspectroscopy', 'image_size', 'Nx').value(), self.settings.child('hyperspectroscopy', 'camera_mode_settings', 'spim_y').value(), self.settings.child('hyperspectroscopy', 'camera_mode_settings', 'spim_x').value())) ], dim='DataND'), DataFromPlugins(name='Spectrum', data=[ np.zeros((self.settings.child( 'hyperspectroscopy', 'image_size', 'Nx').value(), )) ], dim='Data1D') ] self.data_stem = np.zeros((2 * Nx * Ny), dtype=np.int16) self.data_stem_current = np.zeros((2, Nx, Ny), dtype=np.int16) self.data_stem_pointer = self.data_stem.ctypes.data_as(ctypes.c_void_p)
def data_ready(self): """ | Cast the raw data (from Picoscope's communication channel) to export considering time axis in ms. | Send the data grabed signal once done. See Also -------- get_active_channels, daq_utils.ThreadCommand """ try: Nsegments=self.settings.child('main_settings','Nsegments').value() channels=self.get_active_channels() ind_channels=[picoscope.DAQ_Picoscope_trigger_channel[channel].value for channel in channels] data=np.zeros((len(channels),self.Nsample_available,Nsegments)) status,Nsamples=self.pico.get_value_bulk(Nsamples_required=self.Nsample_available,start_segment=0,stop_segment=Nsegments-1) if status!="PICO_OK": self.emit_status(ThreadCommand("Update_Status",[status,'log'])) window_ms=self.settings.child('main_settings','temporal','window').value() self.x_axis,self.Nsample_available=self.get_xaxis(self.settings.child('main_settings','temporal','Nsamples').value(),window_ms*1000) #get time axis in ms self.emit_x_axis() for ind_segment in range(Nsegments): for ind,ind_channel in enumerate(ind_channels): status,data_channel=self.pico.get_data(channel=ind_channel,buffer=self.buffers[ind_segment][ind]) data[ind,:,ind_segment]=data_channel['data'] data_export=[np.sum(data[ind,:,:],axis=1)/Nsegments for ind in range(len(channels))] self.data_grabed_signal.emit([DataFromPlugins(name='picoscope',data=data_export, dim='Data1D')]) except Exception as e: self.emit_status(ThreadCommand("Update_Status",[getLineInfo()+ str(e),'log']))
def counter_done(self): channels = [ child.opts['title'] for child in self.settings.child( 'counter_settings', 'counter_channels').children() ] data_counter = np.zeros(len(channels), dtype='uint32') read = self.PyDAQmx.int32() self.task.ReadCounterU32Ex(self.PyDAQmx.DAQmx_Val_Auto, 10.0, self.PyDAQmx.DAQmx_Val_GroupByChannel, data_counter, len(data_counter), self.PyDAQmx.byref(read), None) self.task.StopTask() data_counter = data_counter.astype(float) data_counter = data_counter / (self.settings.child( 'counter_settings', 'counting_time').value() * 1e-3) self.data_grabed_signal.emit([ DataFromPlugins(name='NI Counter', data=[data_counter], dim='Data0D', labels=channels) ])
def grab_data(self, Naverage=1, **kwargs): """ """ Naverage = 1 if not self.controller_ready: ret = self.controller.prepare_N_acquisition( self.settings.child('acq_params', 'npts_map').value()) if ret == 'ready': self.controller_ready = True else: self.emit_status( ThreadCommand( 'Update_Status', ['Spectrometer not ready to grab data...', 'log'])) if self.controller_ready: data = self.controller.grab_spectrum() else: data = self.controller.wavelength_axis * 0 if data is None: self.emit_status( ThreadCommand('Update_Status', ['No data from spectrometer', 'log'])) data = self.controller.wavelength_axis * 0 self.data_grabed_signal.emit([ DataFromPlugins(name='LabSpec6', data=[data], dim='Data1D', x_axis=Axis(data=self.controller.wavelength_axis, units='nm', label='Wavelength')) ])
def grab_data(self, Naverage=1, **kwargs): """ Parameters ---------- kwargs: (dict) of others optionals arguments """ ##synchrone version (blocking function) if self.calib_on and self.calib_file_ok: label = ["Irradiance (W/m2)"] else: label = ["Signal (counts)"] data_tot = [self.get_data()] if self.snapshot is not None: data_tot.append(self.snapshot) label.append("Snapshot") self.data_grabed_signal.emit([ DataFromPlugins(name="StellarNet", data=data_tot, dim="Data1D", labels=label, x_axis=self.x_axis[0]) ])
def grab_data(self, Naverage=1, **kwargs): """ | Start new acquisition For each integer step of naverage range: * set mock data * wait 100 ms * update the data_tot array | Send the data_grabed_signal once done. =============== ======== =============================================== **Parameters** **Type** **Description** *Naverage* int Number of spectrum to average. Specify the threshold of the mean calculation =============== ======== =============================================== See Also -------- set_Mock_data """ Naverage = 1 data_tot = self.set_Mock_data() for ind in range(Naverage - 1): data_tmp = self.set_Mock_data() QThread.msleep(self.settings.child('exposure_ms').value()) for ind, data in enumerate(data_tmp): data_tot[ind] += data data_tot = [data / Naverage for data in data_tot] QThread.msleep(self.settings.child('exposure_ms').value()) self.data_grabed_signal.emit( [DataFromPlugins(name='Mock1', data=data_tot, dim='Data1D')])
def grab_data(self, Naverage=1, **kwargs): """ | Start new acquisition. | grab the current values with keithley profile procedure. | Send the data_grabed_signal once done. =============== ======== =============================================== **Parameters** **Type** **Description** *Naverage* int Number of values to average =============== ======== =============================================== """ data_tot = [] x_axis = None for ind, channel in enumerate( self.settings.child(('channels')).value()['selected']): if ind == 0: x_axis, data_tmp = self.read_channel_data(channel, x_axis_out=True) else: data_tmp = self.read_channel_data(channel, x_axis_out=False) data_tot.append(data_tmp) self.data_grabed_signal.emit([ DataFromPlugins(name='Tektronix', data=data_tot, dim='Data1D', x_axis=Axis(data=x_axis, label='Time', units='s')) ])
def grab_data(self, Naverage=1, **kwargs): """ Parameters ---------- Naverage: (int) Number of hardware averaging kwargs: (dict) of others optionals arguments """ nlc = self.settings.child('advanced').child( 'correct_non_linearity').value() c0 = self.settings.child('advanced').child('dark_channels').value() # synchrone version (blocking function) # Pseudo-hardware-averaging if Naverage > 1: data = [ self.controller.intensities(correct_nonlinearity=nlc)[c0:] for i in range(Naverage) ] data = np.array(data) data = data.mean(0) # Otherwise normal single-acquisition else: data = self.controller.intensities(correct_nonlinearity=nlc)[c0:] data_emit = DataFromPlugins(name='oceanseabreeze', data=[data], dim='Data1D', labels=['spectrum']) self.data_grabed_signal.emit([data_emit])
def ini_detector(self, controller=None): """ Initialisation procedure of the detector updating the status dictionnary. See Also -------- set_Mock_data, daq_utils.ThreadCommand """ self.status.update(edict(initialized=False,info="",x_axis=None,y_axis=None,controller=None)) try: 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.set_x_axis() self.set_Mock_data() # initialize viewers with the future type of data self.data_grabed_signal_temp.emit([DataFromPlugins(name='Mock1', data=self.data_mock, dim='Data1D', x_axis= self.x_axis, labels=['Mock1', 'label2']),]) self.status.initialized=True self.status.controller=self.controller self.status.x_axis = self.x_axis return self.status except Exception as e: self.emit_status(ThreadCommand('Update_Status',[getLineInfo()+ str(e),'log'])) self.status.info=getLineInfo()+ str(e) self.status.initialized=False return self.status
def emit_data(self): """ Fonction used to emit data obtained by callback. See Also -------- daq_utils.ThreadCommand """ try: self.ind_grabbed += 1 sizey = self.settings.child('camera_settings', 'image_size', 'Ny').value() sizex = self.settings.child('camera_settings', 'image_size', 'Nx').value() self.controller.GetAcquiredDataNumpy(self.data_pointer, sizex * sizey) self.data_grabed_signal.emit([ DataFromPlugins(name='Camera', data=[ np.squeeze( self.data.reshape( (sizey, sizex)).astype(np.float)) ], dim=self.data_shape) ]) QtWidgets.QApplication.processEvents( ) # here to be sure the timeevents are executed even if in continuous grab mode except Exception as e: self.emit_status(ThreadCommand('Update_Status', [str(e), 'log']))
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.set_Mock_data() self.emit_status(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([DataFromPlugins(name='Mock1',data=[np.array(0)], dim='Data0D', labels=['Mock1', 'label2'])]) self.status.initialized = True self.status.controller = self.controller return self.status
def data_ready(self, data): """ Send the grabed data signal. """ self.data_grabed_signal.emit( [DataFromPlugins(name='TCPServer', data=data, dim='Data0D')])
def grab_data(self, Naverage=1, **kwargs): """ """ try: datas = [] for ind_spectro in range(len(self.spectro_names)): if self.settings.child('spectrometers', 'spectro{:d}'.format(ind_spectro), 'grab').value(): self.controller.setScansToAverage(ind_spectro, Naverage) data_chelou = self.controller.getSpectrum(ind_spectro) data = np.array( [data_chelou[ind] for ind in range(len(data_chelou))]) datas.append( DataFromPlugins(name=self.spectro_names[ind_spectro], data=[data], dim='Data1D')) QtWidgets.QApplication.processEvents() self.data_grabed_signal.emit(datas) except Exception as e: self.emit_status( ThreadCommand('Update_Status', [getLineInfo() + str(e), "log"]))
def emit_data(self): """ """ try: mode = self.settings.child('acquisition', 'acq_type').value() if mode == 'Counting' or mode == 'Histo' or mode == 'T3': super(DAQ_2DViewer_FLIM, self).emit_data() elif mode == 'FLIM': self.stop_scanner.emit() self.h5saver.h5_file.flush() datas = self.process_histo_from_h5_and_correct_shifts( self.Nx, self.Ny, channel=0, marker=65) self.data_grabed_signal.emit([ DataFromPlugins(name='TH260', data=datas, dim='DataND', nav_axes=(0, 1), nav_x_axis=self.get_nav_xaxis(), nav_y_axis=self.get_nav_yaxis(), xaxis=self.get_xaxis(), external_h5=self.h5saver.h5_file) ]) self.stop() except Exception as e: self.emit_status( ThreadCommand('Update_Status', [getLineInfo() + str(e), 'log']))
def grab_data(self, Naverage=1, **kwargs): """ Start a new acquisition. Grab the current values. Send the Parameters ---------- Naverage: (int) Number of hardware averaging kwargs: (dict) of others optionals arguments """ # The following seems to be important to refresh the scope buffer. # Otherwise a long scan will crash the daq_scan. self.controller.DeviceClear(False) QtWidgets.QApplication.processEvents() QThread.msleep(100) QtWidgets.QApplication.processEvents() channel = self.settings.child('channels').value()['selected'] waveform = self.controller.GetScaledWaveformWithTimes( channel[0], 1e8, 0) if self.sample_mode == "Sequence": while True: self.controller.WriteString( r"""vbs? 'return=app.acquisition.horizontal.acquiredsegments' """, 1) acquired_segments = self.controller.ReadString(8) if acquired_segments == self.number_of_segments: break time.sleep(0.01) else: pass # The ErrorFlag property checks that there is no error concerning ActiveDSO. # If the user changes some parameters on the oscilloscope (for example the # horizontal scale) while pymodaq acquisition is running, it will raise this # error. We do not know how to deal with this problem. # If the error is raised you will probably have to restart the oscilloscope to # get the communication back. # Restarting can be done with a little script using the DeviceClear(True) method # of ActiveDSO. It is much faster than doing it manually. # # To prevent the error, the user should use the STOP button on pymodaq GUI, then # change the parameter of his choice on the oscilloscope and then RUN pymodaq # acquisition. if self.controller.ErrorFlag: raise Exception(self.controller.ErrorString) data = [np.array(waveform[1])] self.data_grabed_signal.emit([ DataFromPlugins(name='Lecroy Waverunner', data=data, type='Data1D', labels=["", ""]) ])
def ini_detector(self, controller=None): """Detector communication initialization Parameters ---------- controller: (object) custom object of a PyMoDAQ plugin (Slave case). None if only one detector by controller (Master case) Returns ------- self.status (edict): with initialization status: three fields: * info (str) * controller (object) initialized controller *initialized: (bool): False if initialization failed otherwise True """ try: 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: ## TODO for your custom plugin self.controller = python_wrapper_of_your_instrument( ) # any object that will control the stages ##################################### ## TODO for your custom plugin #initialize viewers pannel with the future type of data self.data_grabed_signal_temp.emit([ DataFromPlugins(name='Mock1', data=[np.array([0]), np.array([0])], dim='Data0D', labels=['Mock1', 'label2']) ]) ############################## self.status.info = "Whatever info you want to log" self.status.initialized = True self.status.controller = self.controller return self.status except Exception as e: self.emit_status( ThreadCommand('Update_Status', [getLineInfo() + str(e), 'log'])) self.status.info = getLineInfo() + str(e) self.status.initialized = False return self.status
def _data_ready(self, handle_ptr, p_data, frame_num, data): dat = self.controller.get_image_data() data = np.array(dat[0][:], dtype=np.uint8) data = data.reshape((dat[2], dat[1], 3)) self.data_grabed_signal.emit([ DataFromPlugins(name='TIS ', data=[data[:, :, 0], data[:, :, 1], data[:, :, 2]], dim='Data2D'), ])
def callback(self): """optional asynchrone method called when the detector has finished its acquisition of data""" data_tot = self.controller.your_method_to_get_data_from_buffer() self.data_grabed_signal.emit([ DataFromPlugins(name='Mock1', data=data_tot, dim='Data1D', labels=['dat0', 'data1']) ])
def emit_data(self, data): channels_name = [ch.name for ch in self.channels] data_tot = [] if self.settings.child('diodes').value(): for ind in range(len(self.channels)): data_tot.append(np.array([np.mean(data[ind*self.Nsamples:(ind+1)*self.Nsamples])])) self.data_grabed_signal.emit([DataFromPlugins(name='NI AI', data=data_tot, dim='Data0D', labels=channels_name)]) else: for ind in range(len(self.channels)): data_tot.append(data[ind*self.Nsamples:(ind+1)*self.Nsamples]) ind_cycles = self.settings.child('Ncycles').value() if self.settings.child('plot_cycles').value(): Bfield = data_tot[0] / self.settings.child('resistance').value() * \ self.settings.child('solenoid').value() delta_diode = data_tot[1] diode = (data_tot[2] + data_tot[3]) / 2 else: length = int(1 / self.settings.child('frequency_magnet').value() * self.settings.child('frequency').value()) Bfields = [data_tot[0][ind*length:(ind+1)*length] / self.settings.child('resistance').value() * self.settings.child('solenoid').value() for ind in range(4)] delta_diodes = [data_tot[1][ind*length:(ind+1)*length] for ind in range(4)] diodes = [(data_tot[2][ind*length:(ind+1)*length] + data_tot[3][ind*length:(ind+1)*length]) / 2 for ind in range(4)] if self.settings.child('average_cycles').value(): Bfield = np.mean(np.array(Bfields[ind_cycles:]), 0) delta_diode = np.mean(np.array(delta_diodes[ind_cycles:]), 0) diode = np.mean(np.array(diodes[ind_cycles:]), 0) else: Bfield = Bfields[ind_cycles] delta_diode = delta_diodes[ind_cycles] diode = diodes[ind_cycles] rotation = 180 / np.pi / (self.settings.child('gain').value() * 4) * np.arctan(delta_diode / diode) self.data_grabed_signal.emit([DataFromPlugins(name='NI AI', data=[Bfield, rotation], dim='Data1D', labels=['Bfield', 'Rotation'], x_axis=Axis(data=np.linspace(0, self.Nsamples / self.clock_settings_ai.frequency, self.Nsamples), label='Time', units='s'))])
def emit_data(self): # data_stem = self.data_stem.reshape((2, self.SIZEX, # self.SIZEY)).astype(np.float64) if not self.settings.child(('do_hyperspectroscopy')).value(): data_stem = [ DataFromPlugins(name=self.settings.child( 'stem_settings', 'inputs', 'input1').value(), data=[self.data_stem_current[0]], dim='Data2D'), DataFromPlugins(name=self.settings.child( 'stem_settings', 'inputs', 'input2').value(), data=[self.data_stem_current[1]], dim='Data2D'), ] if self.data_stem_ready: if self.stem_scan_finished: self.data_grabed_signal.emit(data_stem) self.stem_scan.stopImaging(True) else: self.data_grabed_signal_temp.emit(data_stem) else: data_stem = [ DataFromPlugins(name='SPIM ' + self.settings.child( 'stem_settings', 'inputs', 'input1').value(), data=[self.data_stem_current[0]], dim='Data2D'), DataFromPlugins(name='SPIM ' + self.settings.child( 'stem_settings', 'inputs', 'input2').value(), data=[self.data_stem_current[1]], dim='Data2D'), ] if self.data_spectrum_spim_ready and self.stem_scan_finished: #all data have been taken self.spim_scan.stopImaging(True) self.data_grabed_signal.emit(self.data_stem_STEM_as_reference + data_stem + self.data_spectrum_spim) else: self.data_grabed_signal_temp.emit( self.data_stem_STEM_as_reference + data_stem + self.data_spectrum_spim)
def update_camera_mode(self, mode='Camera'): sizex = self.settings.child('image_size', 'Nx').value() sizey = self.settings.child('image_size', 'Ny').value() image_size = sizex * sizey if image_size == 1: self.data_shape = 'Data0D' elif sizex == 1 or sizey == 1: self.data_shape = 'Data1D' else: self.data_shape = 'Data2D' if mode == "Camera": # %%%%%% Initialize data: self.data for the memory to store new data and self.data_average to store the average data self.data = np.zeros((image_size,), dtype=np.float32) self.data_pointer = self.data.ctypes.data_as(ctypes.c_void_p) elif mode == "SPIM": Ny = self.settings.child('image_size', 'Ny').value() self.settings.child('binning_settings', 'bin_y').setValue( Ny * self.settings.child('binning_settings', 'bin_y').value()) self.commit_settings(self.settings.child('binning_settings', 'bin_y')) QtWidgets.QApplication.processEvents() # %%%%%% Initialize data: self.data for the memory to store new data and self.data_average to store the average data SPIMX = self.settings.child('camera_mode_settings', 'spim_x').value() SPIMY = self.settings.child('camera_mode_settings', 'spim_y').value() spimsize = sizex * SPIMY * SPIMX self.spimdata = np.zeros((spimsize,), dtype=np.float32) self.pointeurspim = self.spimdata.ctypes.data_as(ctypes.c_void_p) self.spectrumdata = np.zeros((sizex,), dtype=np.float32) self.pointeurspectrum = self.spectrumdata.ctypes.data_as(ctypes.c_void_p) # init the viewers self.data_grabed_signal_temp.emit([DataFromPlugins(name='SPIM ', data=[self.spimdata.reshape(( self.settings.child('image_size', 'Nx').value(), self.settings.child('camera_mode_settings', 'spim_y').value(), self.settings.child('camera_mode_settings', 'spim_x').value()))], dim='DataND', nav_axes=(1, 2)), DataFromPlugins(name='Spectrum', data=[self.spectrumdata], dim='Data1D')])
def emit_data_live(self): """ temporary datas emitter when acquisition is running """ data_stem = self.data_stem.reshape( (2, self.settings.child('stem_settings', 'pixels_settings', 'Ny').value(), self.settings.child('stem_settings', 'pixels_settings', 'Nx').value())).astype(np.float64) #print('livedata') self.data_grabed_signal_temp.emit([ DataFromPlugins(name=self.settings.child('stem_settings', 'inputs', 'input1').value(), data=[data_stem[0]], dim='Data2D'), DataFromPlugins(name=self.settings.child('stem_settings', 'inputs', 'input2').value(), data=[data_stem[1]], dim='Data2D') ])
def ini_detector(self, controller=None): """ Initialisation procedure of the detector. Returns ------- the initialized status. """ 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: if self.settings.child(('device')).value() != 'no devices': try: self.controller = Keithley2110( self.settings.child(('device')).value()) except Exception as e: raise Exception( 'No controller could be defined because an error occurred\ while connecting to the instrument. Error: {}'.format( str(e))) self.controller.set_mode( self.settings.child('KeithleyParams', 'mode').value()) # initialize viewers with the future type of data self.data_grabed_signal.emit([ DataFromPlugins(name='Keithley2110', data=[np.array([0])], dim='Data0D', labels=['Meas', 'Time']) ]) self.status.initialized = True self.status.controller = self.controller return self.status
def average_data(self, Naverage): data = [] # list of image (at most 3 for red, green and blue channels) data_tmp = np.zeros_like(self.image) for ind in range(Naverage): data_tmp += self.set_Mock_data() data_tmp = data_tmp / Naverage data_tmp = data_tmp * (data_tmp >= self.settings.child('threshold').value()) for ind in range(self.settings.child(('Nimagespannel')).value()): datatmptmp = [] for indbis in range(self.settings.child(('Nimagescolor')).value()): datatmptmp.append(data_tmp) data.append(DataFromPlugins(name='Mock2D_{:d}'.format(ind), data=datatmptmp, dim='Data2D')) # data.append(OrderedDict(name='Mock2D_1D',data=[np.mean(data_tmp,axis=0)], type='Data1D')) return data
def grab_data(self, Naverage=1, **kwargs): """ | Start new acquisition. | grab the current values. | Send the data_grabed_signal once done. =============== ======== =============================================== **Parameters** **Type** **Description** *Naverage* int Number of values to average =============== ======== =============================================== """ data_tot = [] data = self.controller.query_ascii_values('SNAP ? 1,2,3,4,5,6') data.extend(self.controller.query_ascii_values('SNAP ? 7,8,9,10,11')) selected_channels = self.settings.child('config', 'channels').value()['selected'] data_to_export = [ np.array([data[ind]]) for ind in [self.channels.index(sel) for sel in selected_channels] ] if self.settings.child('config', 'separate_viewers').value(): for ind_channel, dat in enumerate(data_to_export): data_tot.append( DataFromPlugins(name=selected_channels[ind_channel], data=[dat], dim='Data0D', labels=[selected_channels[ind_channel]])) self.data_grabed_signal.emit(data_tot) else: self.data_grabed_signal.emit([ DataFromPlugins(name='SR830', data=data_to_export, dim='Data0D', labels=selected_channels) ])