2071848825

Build # 2071848825

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #170 from samuelgarcia/fixbug

Run Details

417 of 1085 branches covered (38.43%)

Branch coverage included in aggregate %.

0 of 6 new or added lines in 5 files covered. (0.0%)

17 existing lines in 3 files now uncovered.

2089 of 3552 relevant lines covered (58.81%)

3.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

55.48

/ephyviewer/spiketrainviewer.py

# -*- coding: utf-8 -*-
#~ from __future__ import (unicode_literals, print_function, division, absolute_import)


import numpy as np

import matplotlib.cm
import matplotlib.colors

from .myqt import QT
import pyqtgraph as pg

from .base import BaseMultiChannelViewer, Base_MultiChannel_ParamController
from .datasource import InMemorySpikeSource, NeoSpikeTrainSource



#make symbol for spikes
from pyqtgraph.graphicsItems.ScatterPlotItem import Symbols
Symbols['|'] = QT.QPainterPath()
Symbols['|'].moveTo(0, -0.5)
Symbols['|'].lineTo(0, 0.5)
Symbols['|'].closeSubpath()




default_params = [
    {'name': 'xsize', 'type': 'float', 'value': 3., 'step': 0.1},
    {'name': 'xratio', 'type': 'float', 'value': 0.3, 'step': 0.1, 'limits': (0,1)},
    {'name': 'scatter_size', 'type': 'float', 'value': 0.8,  'limits': (0,np.inf)},
    {'name': 'background_color', 'type': 'color', 'value': 'k'},
    {'name': 'vline_color', 'type': 'color', 'value': '#FFFFFFAA'},
    {'name': 'label_fill_color', 'type': 'color', 'value': '#222222DD'},
    {'name': 'label_size', 'type': 'int', 'value': 8, 'limits': (1,np.inf)},
    {'name': 'display_labels', 'type': 'bool', 'value': True},
    ]

default_by_channel_params = [
    {'name': 'color', 'type': 'color', 'value': "#55FF00"},
    {'name': 'visible', 'type': 'bool', 'value': True},
    ]




class SpikeTrainViewer_ParamController(Base_MultiChannel_ParamController):
    pass



class DataGrabber(QT.QObject):
    data_ready = QT.pyqtSignal(float, float, object, object)

    def __init__(self, source, parent=None):
        QT.QObject.__init__(self, parent)
        self.source = source

    def on_request_data(self, t_start, t_stop, visibles):
        data = {}
        for e, chan in enumerate(visibles):
            times = self.source.get_chunk_by_time(chan=chan,  t_start=t_start, t_stop=t_stop)
            data[chan] = times
        self.data_ready.emit(t_start, t_stop, visibles, data)


class SpikeTrainViewer(BaseMultiChannelViewer):
    _default_params = default_params
    _default_by_channel_params = default_by_channel_params

    _ControllerClass = SpikeTrainViewer_ParamController

    request_data = QT.pyqtSignal(float, float, object)

    def __init__(self, **kargs):
        BaseMultiChannelViewer.__init__(self, **kargs)

        self.make_params()
        self.set_layout()
        self.make_param_controller()

        self.viewBox.doubleclicked.connect(self.show_params_controller)

        self.initialize_plot()



        self.thread = QT.QThread(parent=self)
        self.datagrabber = DataGrabber(source=self.source)
        self.datagrabber.moveToThread(self.thread)
        self.thread.start()


        self.datagrabber.data_ready.connect(self.on_data_ready)
        self.request_data.connect(self.datagrabber.on_request_data)

        self.params.param('xsize').setLimits((0, np.inf))

    @classmethod
    def from_numpy(cls, all_epochs, name):
        source = InMemorySpikeSource(all_epochs)
        view = cls(source=source, name=name)
        return view

    @classmethod
    def from_neo_spiketrains(cls, neo_spiketrains, name):
        source = NeoSpikeTrainSource(neo_spiketrains)
        view = cls(source=source, name=name)
        return view

    def closeEvent(self, event):
        event.accept()
        self.thread.quit()
        self.thread.wait()


    def initialize_plot(self):
        self.vline = pg.InfiniteLine(angle = 90, movable = False, pen = self.params['vline_color'])
        self.vline.setZValue(1) # ensure vline is above plot elements
        self.plot.addItem(self.vline)

        self.scatter = pg.ScatterPlotItem(size=self.params['scatter_size'], pxMode = False, symbol='|')
        self.plot.addItem(self.scatter)


        self.labels = []
        for c in range(self.source.nb_channel):
            label_name = '{}: {}'.format(c, self.source.get_channel_name(chan=c))
            color = self.by_channel_params.children()[c].param('color').value()
            label = pg.TextItem(label_name, color=color, anchor=(0, 0.5), border=None, fill=self.params['label_fill_color'])
            font = label.textItem.font()
            font.setPointSize(self.params['label_size'])
            label.setFont(font)
            self.plot.addItem(label)
            self.labels.append(label)

        self.viewBox.xsize_zoom.connect(self.params_controller.apply_xsize_zoom)


    def refresh(self):
        xsize = self.params['xsize']
        xratio = self.params['xratio']
        t_start, t_stop = self.t-xsize*xratio , self.t+xsize*(1-xratio)
        visibles, = np.nonzero(self.params_controller.visible_channels)
        self.request_data.emit(t_start, t_stop, visibles)

    def on_data_ready(self, t_start, t_stop, visibles, data):
        self.graphicsview.setBackground(self.params['background_color'])

        self.scatter.clear()
        all_x = []
        all_y = []
        all_brush = []

        for e, chan in enumerate(visibles):
            times = data[chan]

            ypos = visibles.size-e-1

            all_x.append(times)
            all_y.append(np.ones(times.size)*ypos)
            color = self.by_channel_params.children()[chan].param('color').value()
            all_brush.append(np.array([pg.mkPen(color)]*len(times)))


            if self.params['display_labels']:
                self.labels[chan].setPos(t_start, ypos)
                self.labels[chan].show()
                self.labels[chan].setColor(color)

        for chan in range(self.source.nb_channel):
            if not self.params['display_labels'] or chan not in visibles:
                self.labels[chan].hide()

        for label in self.labels:
            label.fill = pg.mkBrush(self.params['label_fill_color'])

        if len(all_x):
            all_x = np.concatenate(all_x)
            all_y = np.concatenate(all_y)
            all_brush = np.concatenate(all_brush)
            self.scatter.setData(x=all_x, y=all_y, pen=all_brush)

        self.vline.setPen(self.params['vline_color'])
        self.vline.setPos(self.t)

        self.plot.setXRange( t_start, t_stop, padding = 0.0)
        self.plot.setYRange(-self.params['scatter_size']/2, self.params['scatter_size']/2 + visibles.size - 1)

    def on_param_change(self, params=None, changes=None):
        for param, change, data in changes:
            if change != 'value': continue
            if param.name()=='scatter_size':
                self.scatter.setSize(self.params['scatter_size'])
            if param.name()=='label_size':
                for label in self.labels:
                    font = label.textItem.font()
                    font.setPointSize(self.params['label_size'])
                    label.setFont(font)

        self.refresh()

1	# -- coding: utf-8 --
2	#~ from __future__ import (unicode_literals, print_function, division, absolute_import)
3
4
5	import numpy as np	6✔
6
7	import matplotlib.cm	6✔
8	import matplotlib.colors	6✔
9
10	from .myqt import QT	6✔
11	import pyqtgraph as pg	6✔
12
13	from .base import BaseMultiChannelViewer, Base_MultiChannel_ParamController	6✔
14	from .datasource import InMemorySpikeSource, NeoSpikeTrainSource	6✔
15
16
17
18	#make symbol for spikes
19	from pyqtgraph.graphicsItems.ScatterPlotItem import Symbols	6✔
20	Symbols['\|'] = QT.QPainterPath()	6✔
21	Symbols['\|'].moveTo(0, -0.5)	6✔
22	Symbols['\|'].lineTo(0, 0.5)	6✔
23	Symbols['\|'].closeSubpath()	6✔
24
25
26
27
28	default_params = [	6✔
29	{'name': 'xsize', 'type': 'float', 'value': 3., 'step': 0.1},
30	{'name': 'xratio', 'type': 'float', 'value': 0.3, 'step': 0.1, 'limits': (0,1)},
31	{'name': 'scatter_size', 'type': 'float', 'value': 0.8, 'limits': (0,np.inf)},
32	{'name': 'background_color', 'type': 'color', 'value': 'k'},
33	{'name': 'vline_color', 'type': 'color', 'value': '#FFFFFFAA'},
34	{'name': 'label_fill_color', 'type': 'color', 'value': '#222222DD'},
35	{'name': 'label_size', 'type': 'int', 'value': 8, 'limits': (1,np.inf)},
36	{'name': 'display_labels', 'type': 'bool', 'value': True},
37	]
38
39	default_by_channel_params = [	6✔
40	{'name': 'color', 'type': 'color', 'value': "#55FF00"},
41	{'name': 'visible', 'type': 'bool', 'value': True},
42	]
43
44
45
46
47	class SpikeTrainViewer_ParamController(Base_MultiChannel_ParamController):	6✔
48	pass	6✔
49
50
51
52	class DataGrabber(QT.QObject):	6✔
53	data_ready = QT.pyqtSignal(float, float, object, object)	6✔
54
55	def __init__(self, source, parent=None):	6✔
56	QT.QObject.__init__(self, parent)	6✔
57	self.source = source	6✔
58
59	def on_request_data(self, t_start, t_stop, visibles):	6✔
60	data = {}	×
61	for e, chan in enumerate(visibles):	×
62	times = self.source.get_chunk_by_time(chan=chan, t_start=t_start, t_stop=t_stop)	×
63	data[chan] = times	×
64	self.data_ready.emit(t_start, t_stop, visibles, data)	×
65
66
67	class SpikeTrainViewer(BaseMultiChannelViewer):	6✔
68	_default_params = default_params	6✔
69	_default_by_channel_params = default_by_channel_params	6✔
70
71	_ControllerClass = SpikeTrainViewer_ParamController	6✔
72
73	request_data = QT.pyqtSignal(float, float, object)	6✔
74
75	def __init__(self, **kargs):	6✔
76	BaseMultiChannelViewer.__init__(self, **kargs)	6✔
77
78	self.make_params()	6✔
79	self.set_layout()	6✔
80	self.make_param_controller()	6✔
81
82	self.viewBox.doubleclicked.connect(self.show_params_controller)	6✔
83
84	self.initialize_plot()	6✔
85
86
87
88	self.thread = QT.QThread(parent=self)	6✔
89	self.datagrabber = DataGrabber(source=self.source)	6✔
90	self.datagrabber.moveToThread(self.thread)	6✔
91	self.thread.start()	6✔
92
93
94	self.datagrabber.data_ready.connect(self.on_data_ready)	6✔
95	self.request_data.connect(self.datagrabber.on_request_data)	6✔
96
97	self.params.param('xsize').setLimits((0, np.inf))	6✔
98
99	@classmethod	6✔
100	def from_numpy(cls, all_epochs, name):	4✔
101	source = InMemorySpikeSource(all_epochs)	×
102	view = cls(source=source, name=name)	×
103	return view	×
104
105	@classmethod	6✔
106	def from_neo_spiketrains(cls, neo_spiketrains, name):	4✔
107	source = NeoSpikeTrainSource(neo_spiketrains)	×
108	view = cls(source=source, name=name)	×
109	return view	×
110
111	def closeEvent(self, event):	6✔
112	event.accept()	6✔
113	self.thread.quit()	6✔
114	self.thread.wait()	6✔
115
116
117	def initialize_plot(self):	6✔
118	self.vline = pg.InfiniteLine(angle = 90, movable = False, pen = self.params['vline_color'])	6✔
119	self.vline.setZValue(1) # ensure vline is above plot elements	6✔
120	self.plot.addItem(self.vline)	6✔
121
122	self.scatter = pg.ScatterPlotItem(size=self.params['scatter_size'], pxMode = False, symbol='\|')	6✔
123	self.plot.addItem(self.scatter)	6✔
124
125
126	self.labels = []	6✔
127	for c in range(self.source.nb_channel):	6✔
128	label_name = '{}: {}'.format(c, self.source.get_channel_name(chan=c))	6✔
129	color = self.by_channel_params.children()[c].param('color').value()	6✔
130	label = pg.TextItem(label_name, color=color, anchor=(0, 0.5), border=None, fill=self.params['label_fill_color'])	6✔
131	font = label.textItem.font()	6✔
132	font.setPointSize(self.params['label_size'])	6✔
133	label.setFont(font)	6✔
134	self.plot.addItem(label)	6✔
135	self.labels.append(label)	6✔
136
137	self.viewBox.xsize_zoom.connect(self.params_controller.apply_xsize_zoom)	6✔
138
139
140	def refresh(self):	6✔
141	xsize = self.params['xsize']	6✔
142	xratio = self.params['xratio']	6✔
143	t_start, t_stop = self.t-xsizexratio , self.t+xsize(1-xratio)	6✔
144	visibles, = np.nonzero(self.params_controller.visible_channels)	6✔
145	self.request_data.emit(t_start, t_stop, visibles)	6✔
146
147	def on_data_ready(self, t_start, t_stop, visibles, data):	6✔
148	self.graphicsview.setBackground(self.params['background_color'])	×
149
150	self.scatter.clear()	×
151	all_x = []	×
152	all_y = []	×
153	all_brush = []	×
154
155	for e, chan in enumerate(visibles):	×
156	times = data[chan]	×
157
158	ypos = visibles.size-e-1	×
159
160	all_x.append(times)	×
161	all_y.append(np.ones(times.size)*ypos)	×
162	color = self.by_channel_params.children()[chan].param('color').value()	×
163	all_brush.append(np.array([pg.mkPen(color)]*len(times)))	×
164
165
166	if self.params['display_labels']:	×
167	self.labels[chan].setPos(t_start, ypos)	×
168	self.labels[chan].show()	×
169	self.labels[chan].setColor(color)	×
170
171	for chan in range(self.source.nb_channel):	×
172	if not self.params['display_labels'] or chan not in visibles:	×
173	self.labels[chan].hide()	×
174
175	for label in self.labels:	×
176	label.fill = pg.mkBrush(self.params['label_fill_color'])	×
177
178	if len(all_x):	×
179	all_x = np.concatenate(all_x)	×
180	all_y = np.concatenate(all_y)	×
181	all_brush = np.concatenate(all_brush)	×
182	self.scatter.setData(x=all_x, y=all_y, pen=all_brush)	×
183
NEW 184	self.vline.setPen(self.params['vline_color'])	×
185	self.vline.setPos(self.t)	×
186
187	self.plot.setXRange( t_start, t_stop, padding = 0.0)	×
188	self.plot.setYRange(-self.params['scatter_size']/2, self.params['scatter_size']/2 + visibles.size - 1)	×
189
190	def on_param_change(self, params=None, changes=None):	6✔
191	for param, change, data in changes:	6✔
192	if change != 'value': continue	6!
193	if param.name()=='scatter_size':	×
194	self.scatter.setSize(self.params['scatter_size'])	×
195	if param.name()=='label_size':	×
196	for label in self.labels:	×
197	font = label.textItem.font()	×
198	font.setPointSize(self.params['label_size'])	×
199	label.setFont(font)	×
200
201	self.refresh()	6✔

NeuralEnsemble / ephyviewer / 2071848825

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous