def __init__(self, input_stream, timeout=200, parent=None): QtCore.QThread.__init__(self, parent) self.input_stream = weakref.ref(input_stream) self.timeout = timeout self.running = False self.running_lock = Mutex() self.lock = Mutex() self._pos = None
def __init__(self): MainWindowNode.__init__(self) self.layout = QT.QVBoxLayout() self.setLayout(self.layout) self.docks = {} self.docks['overview'] = QT.QDockWidget('overview') self.overview = WidgetOverview(self) self.docks['overview'].setWidget(self.overview) self.addDockWidget(QT.TopDockWidgetArea, self.docks['overview']) self.create_actions_and_menu() self.dialog_fullchain_params = ParamDialog(fullchain_params, parent=self) self.dialog_fullchain_params.params['duration'] = 10. # for debug self.dialog_fullchain_params.params['peak_detector', 'relative_threshold'] = 8 self.dialog_fullchain_params.resize(450, 600) self.dialog_method_features = MethodDialog( features_params_by_methods, parent=self, title='Which feature method ?', selected_method='peak_max') self.dialog_method_cluster = MethodDialog( cluster_params_by_methods, parent=self, title='Which cluster method ?', selected_method='sawchaincut') self.mutex = Mutex()
def __init__(self, out_stream, container, parent=None): QtCore.QThread.__init__(self) self.out_stream = out_stream self.container = container self.lock = Mutex() self.running = False
def __init__(self, **kargs): WidgetNode.__init__(self, **kargs) self.layout = QT.QVBoxLayout() self.setLayout(self.layout) h = QT.QHBoxLayout() self.layout.addLayout(h) self.combobox = QT.QComboBox() h.addWidget(self.combobox) but = QT.QPushButton('clear') h.addWidget(but) but.clicked.connect(self.on_clear) self.label = QT.QLabel('') h.addWidget(self.label) self.graphicsview = pg.GraphicsView() self.layout.addWidget(self.graphicsview) self.params = pg.parametertree.Parameter.create(name='settings', type='group', children=self._params) self.tree_params = pg.parametertree.ParameterTree(parent=self) self.tree_params.header().hide() self.tree_params.setParameters(self.params, showTop=True) self.tree_params.setWindowTitle('Options for waveforms hist viewer') self.tree_params.setWindowFlags(QT.Qt.Window) self.params.sigTreeStateChanged.connect(self.on_params_changed) self.initialize_plot() self.mutex = Mutex()
def __init__(self, node, parent=None): QtCore.QThread.__init__(self, parent=parent) self.node = node self.lock = Mutex() self.running = False
def _initialize(self): os.mkdir(self.dirname) self.files = [] self.threads = [] self.mutex = Mutex() self._stream_properties = collections.OrderedDict() for name, input in self.inputs.items(): filename = os.path.join(self.dirname, name+'.raw') fid = open(filename, mode='wb') self.files.append(fid) thread = ThreadRec(name, input, fid) self.threads.append(thread) thread.recv_start_index.connect(self.on_start_index) prop = {} for k in ('streamtype', 'dtype', 'shape', 'sample_rate'): prop[k] = input.params[k] self._stream_properties[name] = prop self._stream_properties['pyacq_version'] = pyacq_version self._flush_stream_properties() self._annotations = {}
def __init__(self, input_stream, timeout=200, return_data=None, parent=None): QtCore.QThread.__init__(self, parent) self.input_stream = weakref.ref(input_stream) self.timeout = timeout self.return_data = return_data if self.return_data is None: self.return_data = self.input_stream()._own_buffer self.running = False self.running_lock = Mutex() self.lock = Mutex() self._pos = None atexit.register(self.stop)
def __init__(self, input_stream, output_stream, timeout=200, parent=None): ThreadPollInput.__init__(self, input_stream, timeout=timeout, return_data=True, parent=parent) self.output_stream = output_stream self.mutex = Mutex()
def __init__(self, outputs, brainamp_host, brainamp_port, nb_channel, parent=None): QtCore.QThread.__init__(self) self.outputs = outputs self.brainamp_host= brainamp_host self.brainamp_port= brainamp_port self.nb_channel = nb_channel self.lock = Mutex() self.running = False
def __init__(self, frame_grabber, video_index, parent=None): QT.QObject.__init__(self, parent) self.fg = frame_grabber self.video_index = video_index self.mutex = Mutex() self.request_list = [] self._last_frame = None
def __init__(self, name='', parent=None): self.name = name self.lock = Mutex() # on lock for all state self._running = False self._configured = False self._initialized = False self._closed = False self.inputs = {name:InputStream(spec=spec, node=self, name=name) for name, spec in self._input_specs.items()} self.outputs = {name:OutputStream(spec=spec, node=self, name=name) for name, spec in self._output_specs.items()}
def __init__(self, input_stream, output_streams, peeler,in_group_channels, timeout = 200, parent = None): ThreadPollInput.__init__(self, input_stream, timeout=timeout, return_data=True, parent = parent) self.output_streams = output_streams self.peeler = peeler self.in_group_channels = in_group_channels self.sample_rate = input_stream.params['sample_rate'] self.total_channel = self.input_stream().params['shape'][1] self.mutex = Mutex()
def __init__(self, outputs, serial_port, nb_channel, nb_aux): QtCore.QThread.__init__(self) self.outputs = outputs self.n = 0 self.serial_port = serial_port self.packet_bsize = 3 + (nb_channel * 3) + (nb_aux * 2) self.chan_values = np.zeros((1, nb_channel), dtype=np.int64) self.aux_values = np.zeros((1, nb_aux), dtype=np.int64) self.count_lost_bytes = 0 self.nb_channel = nb_channel self.nb_aux = nb_aux self.lock = Mutex() self.running = False
def _initialize(self): if not os.path.exists(self.dirname): os.mkdir(self.dirname) #~ self.files = [] self.av_containers = [] self.av_streams = [] self.threads = [] self.mutex = Mutex() self._stream_properties = collections.OrderedDict() for name, input in self.inputs.items(): filename = os.path.join(self.dirname, name + '.avi') sr = input.params['sample_rate'] # this fix problem inside PyAV sr = fractions.Fraction(sr).limit_denominator() av_container = av.open(filename, mode='w') av_stream = av_container.add_stream(self.codec_name, rate=sr) av_stream.width = input.params['shape'][1] av_stream.height = input.params['shape'][0] av_stream.pix_fmt = 'yuv420p' self.av_containers.append(av_container) self.av_streams.append(av_stream) #~ fid = open(filename, mode='wb') #~ self.files.append(fid) thread = ThreadRec(name, input, av_container, av_stream) self.threads.append(thread) thread.recv_start_index.connect(self.on_start_index) prop = {} for k in ('streamtype', 'dtype', 'shape', 'sample_rate'): prop[k] = input.params[k] self._stream_properties[name] = prop self._stream_properties['pyacq_version'] = pyacq_version self._flush_stream_properties() self._annotations = {}
def _initialize(self): self.audiostream = self.pa.open( rate=int(self.sample_rate), channels=int(self.nb_channel), format=format_conv[self.format], input=self.input_device_index is not None, output=self.output_device_index is not None, input_device_index=self.input_device_index, output_device_index=self.output_device_index, frames_per_buffer=self._chunksize, stream_callback=self._audiocallback, start=False) # outbuffer size = self.nb_channel * self._chunksize * np.dtype( self.format).itemsize self.empty_outputbuffer = b'\x00' * size self.out_queue = collections.deque() self.lock = Mutex() if self.output_device_index is not None: self.thread = ThreadPollInput(self.input, return_data=True) self.thread.new_data.connect(self._new_output_buffer)
def __init__(self, configuration_file=None): QT.QMainWindow.__init__(self) self.setDockNestingEnabled(True) self.configured = False self.docks = {} self.conf = {} self.create_toolbar() #~ self.create_layout() self.timer_auto_scale = QT.QTimer(singleShot=True, interval=500) self.timer_auto_scale.timeout.connect(self.auto_scale_all) self.timer_rec = QT.QTimer(singleShot=False, interval=200) self.timer_rec.timeout.connect(self.refresh_rec_duration) self.is_recording = False self.is_running = False self.mutex = Mutex() self.configuration_file = configuration_file self.open_settings()
def __init__(self, dev_handle, parent=None): QtCore.QThread.__init__(self, parent=parent) self.lock = Mutex() self.running = False self.dev_handle = dev_handle
def _initialize(self, ): self.sample_rate = sr = self.input.params['sample_rate'] d0, d1 = self.input.params['shape'] self.nb_channel = self.input.params['nb_channel'] # create proxy input to ensure sharedarray with time axis 1 if self.input.params['transfermode'] == 'sharedarray' and self.input.params['timeaxis'] == 1: self.conv = None else: # if input is not transfermode creat a proxy if self.local_workers: self.conv = StreamConverter() else: ng = self.nodegroup_friends[-1] self.conv = ng.create_node('StreamConverter') self.conv.ng_proxy = ng self.conv.configure() # the inputstream is not needed except for parameters input_spec = dict(self.input.params) self.conv.input.connect(input_spec) if self.input.params['timeaxis']==0: new_shape = (d1, d0) else: new_shape = (d0, d1) self.conv.output.configure(protocol='tcp', interface='127.0.0.1', port='*', dtype='float32', transfermode='sharedarray', streamtype='analogsignal', shape=new_shape, timeaxis=1, compression='', scale=None, offset=None, units='', sharedarray_shape=(self.nb_channel, int(sr*self.max_xsize)), ring_buffer_method = 'double', ) self.conv.initialize() self.workers = [] self.input_maps = [] self.global_poller = ThreadPollInput(input_stream=self.input) self.global_timer = QtCore.QTimer(interval=500) self.global_timer.timeout.connect(self.compute_maps) if not self.local_workers: self.map_pollers = [] for i in range(self.nb_channel): # create worker if self.local_workers: worker = TimeFreqWorker() else: ng = self.nodegroup_friends[i%max(len(self.nodegroup_friends)-1, 1)] worker = ng.create_node('TimeFreqWorker') worker.ng_proxy = ng worker.configure(max_xsize=self.max_xsize, channel=i, local=self.local_workers) worker.input.connect(self.conv.output) if self.local_workers: protocol = 'inproc' else: protocol = 'tcp' worker.output.configure(protocol=protocol, transfermode='plaindata') worker.initialize() self.workers.append(worker) # socket stream for maps from worker input_map = InputStream() out_params = worker.output.params if not isinstance(out_params, dict): # worker is remote; request attribute from remote process. out_params = out_params._get_value() else: # copy to prevent modification out_params = dict(out_params) stream_spec = out_params input_map.connect(worker.output) self.input_maps.append(input_map) if self.local_workers: worker.wt_map_done.connect(self.on_new_map_local) else: poller = ThreadPollInput(input_stream=input_map) poller.new_data.connect(self.on_new_map_socket) poller.chan = i self.map_pollers.append(poller) # This is used to diffred heavy action whena changing params (setting plots, compute wavelet, ...) # this avoid overload on CPU if multiple changes occurs in a short time self.mutex_action = Mutex() self.actions = OrderedDict([(self.create_grid, False), (self.initialize_time_freq, False), (self.initialize_plots, False), ]) self.timer_action = QtCore.QTimer(singleShot=True, interval=300) self.timer_action.timeout.connect(self.apply_actions) # Create parameters all = [] for i in range(self.nb_channel): name = 'Signal{}'.format(i) all.append({'name': name, 'type': 'group', 'children': self._default_by_channel_params}) self.by_channel_params = pg.parametertree.Parameter.create(name='AnalogSignals', type='group', children=all) self.params = pg.parametertree.Parameter.create(name='Global options', type='group', children=self._default_params) self.all_params = pg.parametertree.Parameter.create(name='all param', type='group', children=[self.params,self.by_channel_params]) self.params.param('xsize').setLimits([16./sr, self.max_xsize*.95]) self.all_params.sigTreeStateChanged.connect(self.on_param_change) if self.with_user_dialog: self.params_controller = TimeFreqController(parent=self, viewer=self) self.params_controller.setWindowFlags(QtCore.Qt.Window) else: self.params_controller = None self.create_grid() self.initialize_time_freq() self.initialize_plots()
def _initialize(self, ): assert len(self.input.params['shape']) == 2, 'Are you joking ?' self.sample_rate = sr = self.input.params['sample_rate'] self.nb_channel = self.input.params['shape'][1] buf_size = int(self.input.params['sample_rate'] * self.max_xsize) # channel names channel_info = self.inputs['signals'].params.get('channel_info', None) if channel_info is None: self.channel_names = [ 'ch{}'.format(c) for c in range(self.nb_channel) ] else: self.channel_names = [ch_info['name'] for ch_info in channel_info] # create proxy input to ensure sharedarray with time axis 1 if self.input.params['transfermode'] == 'sharedmem' and self.input.params['axisorder'] is not None \ and tuple(self.input.params['axisorder']) == (1,0): self.conv = None # TODO raise here else: # if input is not transfermode creat a proxy if self.local_workers: self.conv = StreamConverter() else: ng = self.nodegroup_friends[-1] self.conv = ng.create_node('StreamConverter') self.conv.ng_proxy = ng self.conv.configure() # the inputstream is not needed except for parameters input_spec = dict(self.input.params) self.conv.input.connect(input_spec) self.conv.output.configure( protocol='tcp', interface='127.0.0.1', port='*', dtype='float32', transfermode='sharedmem', streamtype='analogsignal', buffer_size=buf_size, axisorder=[1, 0], shape=(-1, self.nb_channel), double=True, fill=0, ) self.conv.initialize() self.workers = [] self.input_maps = [] #~ self.global_poller = ThreadPollInput(input_stream=self.input, return_data=None) # only valid when no conv self.global_poller = ThreadPollOutput(output_stream=self.conv.output, return_data=False) self.global_timer = QtCore.QTimer(interval=500) self.global_timer.timeout.connect(self.compute_maps) if not self.local_workers: self.map_pollers = [] for i in range(self.nb_channel): # create worker if self.local_workers: worker = TimeFreqWorker() else: ng = self.nodegroup_friends[i % max( len(self.nodegroup_friends) - 1, 1)] worker = ng.create_node('TimeFreqWorker') worker.ng_proxy = ng worker.configure(channel=i, local=self.local_workers) worker.input.connect(self.conv.output) if self.local_workers: protocol = 'inproc' else: protocol = 'tcp' worker.output.configure(protocol=protocol, transfermode='plaindata') worker.initialize() self.workers.append(worker) # socket stream for maps from worker input_map = InputStream() out_params = worker.output.params if not isinstance(out_params, dict): # worker is remote; request attribute from remote process. out_params = out_params._get_value() else: # copy to prevent modification out_params = dict(out_params) stream_spec = out_params input_map.connect(worker.output) self.input_maps.append(input_map) if self.local_workers: worker.wt_map_done.connect(self.on_new_map_local) else: poller = ThreadPollInput(input_stream=input_map, return_data=True) poller.new_data.connect(self.on_new_map_socket) poller.chan = i self.map_pollers.append(poller) # This is used to diffred heavy action whena changing params (setting plots, compute wavelet, ...) # this avoid overload on CPU if multiple changes occurs in a short time self.mutex_action = Mutex() self.actions = OrderedDict([ (self.create_grid, False), (self.initialize_time_freq, False), (self.initialize_plots, False), ]) self.timer_action = QtCore.QTimer(singleShot=True, interval=300) self.timer_action.timeout.connect(self.apply_actions) # Create parameters all = [] for i in range(self.nb_channel): by_chan_p = [{ 'name': 'label', 'type': 'str', 'value': self.channel_names[i], 'readonly': True }] + list(self._default_by_channel_params) all.append({ 'name': 'ch{}'.format(i), 'type': 'group', 'children': by_chan_p }) self.by_channel_params = pg.parametertree.Parameter.create( name='AnalogSignals', type='group', children=all) self.params = pg.parametertree.Parameter.create( name='Global options', type='group', children=self._default_params) self.all_params = pg.parametertree.Parameter.create( name='all param', type='group', children=[self.params, self.by_channel_params]) self.params.param('xsize').setLimits([16. / sr, self.max_xsize * .95]) self.all_params.sigTreeStateChanged.connect(self.on_param_change) if self.with_user_dialog: self.params_controller = TimeFreqController(parent=self, viewer=self) self.params_controller.setWindowFlags(QtCore.Qt.Window) else: self.params_controller = None self.create_grid() self.initialize_time_freq() self.initialize_plots()
def __init__(self, **kargs): QOscilloscope.__init__(self, **kargs) self.mutex = Mutex()
def __init__(self, input_stream, **kargs): ThreadPollInput.__init__(self, input_stream, **kargs) self.limit_lock = Mutex() self.limit_indexes = []