def render(self):
style0 = dict(position='absolute',
left='0px',
bottom='0px',
height='{}px'.format(self._height))
divs = [vd.div(tab, style={'float': 'left'}) for tab in self._tabs]
return vd.div(divs, style=style0)
def render(self):
style_plot = {
'position': 'relative',
'border': 'solid 1px black',
'background-color': 'white',
'left': '10px',
'bottom': '10px',
'width': '{}px'.format(self._size_plot[0]),
'height': '{}px'.format(self._size_plot[1])
}
style1 = {
'width': '{}px'.format(self._size[0]),
'height': '{}px'.format(self._size[1])
}
if self._selected:
style1['background-color'] = 'rgb(240,240,200)'
style1['border'] = 'solid 1px gray'
if self._current:
style1['background-color'] = 'rgb(220,220,180)'
if self._current:
style1['border'] = 'solid 2px rgb(150,50,50)'
return vd.div(vd.p('Unit {}'.format(self._unit_id),
style={'text-align': 'center'}),
vd.div(self._plot, style=style_plot, size=()),
style=style1)
def render(self):
if self._geometry is None:
return vd.div('geometry not set')
if self._spikes is None:
return vd.div('spikes not set')
div = vd.div(id=self._elmt_id)
js = """
function wait_for_ready(cb) {
if ((window.d3)&&(window.Simplot)&&(window.SpikeforestWidgets)&&(document.getElementById('{elmt_id}'))) cb();
else setTimeout(function() {wait_for_ready(cb);},10);
}
wait_for_ready(function() {
let SpikeWaveformsWidget=window.SpikeforestWidgets.SpikeWaveformsWidget;
let div=document.getElementById('{elmt_id}');
$(div).empty();
let W=new SpikeWaveformsWidget(div);
W.setSize({width},{height});
W.setGeometry(JSON.parse('{geom}'))
let spikes=JSON.parse('{spikes}');
for (let i=0; i<spikes.length; i++) {
W.addSpike('spike-'+i,spikes[i]);
}
/*
let geom=[[0.5,1],[1.5,1],[0,0],[1,0],[2,0],[0.5,-1],[1.5,-1]];
W.setGeometry(geom);
let num_channels=geom.length;
let tmp1=[0,1,2,3,4,6,12,20,12,6,4,3,2,1,0];
let tmp2=[0,1,2,3,4,6,12,5,12,6,4,3,2,1,0];
let data=[tmp1,tmp2,tmp2,tmp2,tmp2,tmp2,tmp2,tmp2];
let noise_level=5;
let num_spikes=35;
for (let i=0; i<num_spikes; i++) {
let data0=[];
for (let m=0; m<num_channels; m++) {
data0.push(data[m].map(function(v) {return v+Math.random()*noise_level;}));
}
W.addSpike('spike-'+i,data0);
}
*/
});
"""
js = js.replace('{elmt_id}', self._elmt_id)
js = js.replace('{width}', '{}'.format(self._size[0]))
js = js.replace('{height}', '{}'.format(self._size[1]))
js = js.replace('{geom}', json.dumps(self._geometry))
spikes = []
for spike0 in self._spikes:
a = []
for m in range(spike0.shape[0]):
a.append(spike0[m, :].tolist())
spikes.append(a)
js = js.replace('{spikes}', json.dumps(spikes))
# def array_to_json(X):
# return json.dumps([str(v) for v in np.array(X).tolist()])
# x0=array_to_json(self._x)
# y0=array_to_json(self._y)
# js=js.replace('{x}',x0)
# js=js.replace('{y}',y0)
vd.devel.loadJavascript(js=js, delay=0)
return div
def render(self):
style0 = {'border': 'solid 1px black', 'margin': '5px'}
style1 = {}
# if self._selected:
# style1['background-color']='yellow'
return vd.div(vd.p('Title'),
vd.div(self._plot_div, style=style0),
style=style1)
def render(self):
box_style = dict(float='left')
boxes = [
vd.div(W, id=self._uuid + '-{}'.format(i), style=box_style)
for i, W in enumerate(self._widgets)
]
div = vd.div(boxes, style=dict(overflow='auto', height='100%'))
return div
def render(self):
style0 = {'border': 'solid 1px black', 'margin': '5px'}
style1 = {}
if self._selected:
style1['background-color'] = 'yellow'
return vd.div(vd.p('Unit {}'.format(self._unit_id),
style={'text-align': 'center'}),
vd.div(self._plot_div, style=style0),
style=style1)
def render(self):
if self._view:
X = self._view
else:
X = vd.components.ScrollArea(
vd.div(vd.h3('Preparing...'),
vd.pre(self._prepare_log_text_view)),
height=self._size[1] - self._title_bar.height())
return vd.div(self._title_bar, X)
def render(self):
if self._unit_id is None:
return vd.div(vd.h3('No current unit selected.'))
if self._unit_detail_widget:
return vd.div(self._unit_detail_widget)
else:
return vd.div(vd.h3('Initializing......'),
vd.pre(self._init_log_text),
style=dict(overflow='auto'))
def render(self):
try:
size = self._child.size() # if it has the size method
except:
print('Warning: child of LazyDiv does not have a size() method')
size = (300, 300)
div_style = dict()
div_style['width'] = '{}px'.format(size[0])
div_style['height'] = '{}px'.format(size[1])
if self._has_been_seen:
return vd.div(self._child, style=div_style)
else:
callback_id = 'lazydiv-callback-' + str(uuid.uuid4())
vd.register_callback(callback_id, self._on_visible)
js = """
function do_initialize(elmt) {
var called=false;
var io = new IntersectionObserver(
entries => {
if (entries[0].isIntersecting) {
if (!called) {
window.vdomr_invokeFunction('{callback_id}', [], {})
called=true;
io.disconnect();
}
}
},
{
// Using default options.
}
);
io.observe(elmt);
}
var num_initialize_tries=0;
function initialize() {
num_initialize_tries=num_initialize_tries+1;
var elmt=document.getElementById('{div_id}');
if (elmt) {
do_initialize(elmt);
}
else {
if (num_initialize_tries>100) {
console.warn('Problem initializing LazyDiv.');
return;
}
setTimeout(function() {
initialize();
},500);
}
}
initialize();
"""
js = self._div_id.join(js.split('{div_id}'))
js = callback_id.join(js.split('{callback_id}'))
vd.devel.loadJavascript(js=js, delay=100)
return vd.div('Loading...', id=self._div_id, style=div_style)
def render(self):
if self._unit_table_widget:
return vd.div(
self._unit_table_widget
)
else:
return vd.div(
vd.h3('Initializing......'),
style=dict(overflow='auto')
)
def render(self):
if self._job is None:
return vd.div('No job')
back_button = vd.button('Back to job list', onclick=self._on_back)
console_out = None
if 'result' in self._job:
console_out = mt.loadText(
path=self._job['result'].get('console_out', None))
return vd.div(vd.div(back_button), vd.div(vd.pre(console_out or '')),
vd.div(vd.pre(json.dumps(self._job, indent=4))))
def render(self):
if self._list_mode:
refresh_list_button = vd.button('Refresh',
onclick=self._on_refresh_list)
return vd.div(vd.table(vd.tr(vd.td(refresh_list_button))),
vd.components.ScrollArea(self._batchlist_table,
height=500),
style=dict(padding='15px'))
else:
# back_button=vd.button('Back to list',onclick=self._on_back_to_list)
return vd.div(self._batch_view, style=dict(padding='15px'))
def render(self):
style0 = {'border': 'solid 1px black', 'margin': '5px'}
style1 = {}
if self._selected:
style1['background-color'] = 'yellow'
if self._unit1_id == self._unit2_id:
title0 = 'Unit {}'.format(self._unit1_id)
else:
title0 = '{} / {}'.format(self._unit1_id, self._unit2_id)
return vd.div(vd.p(title0, style={'text-align': 'center'}),
vd.div(self._plot_div, style=style0),
style=style1)
def render(self):
if self._batch_id is None:
return vd.div('No batch id')
if self._list_mode:
refresh_button = vd.button('Refresh', onclick=self._on_refresh)
back_button = vd.button('Back to batches', onclick=self._on_back)
label = self._batch.get('label', 'nolabel')
return vd.div(vd.div(self._batch_id + ' ' + label),
vd.div(refresh_button, back_button), self._job_table)
else:
# back_button=vd.button('Back to job list',onclick=self._on_back_to_list)
return vd.div(self._job_view, style=dict(padding='15px'))
def render(self):
if self._current_window:
return vd.div(vd.a('home', onclick=self._on_home),
self._current_window)
elmts = [
vd.a(item['label'],
onclick=lambda item=item: self._open_item(item))
for item in self._contents
]
rows = [vd.tr(vd.td(elmt)) for elmt in elmts]
table = vd.table(rows)
return vd.div(table, style=dict(padding='30px'))
def render(self):
style_outer = dict(width='100%', height='100%', position='absolute')
style_content = dict(left='5px',
right='5px',
top='{}px'.format(5 + self._tab_bar.height()),
bottom='5px',
position='absolute')
onclick = self._on_click
return vd.div(self._highlight_box,
vd.div(self._content,
id='content-' + self.componentId(),
style=style_content),
self._tab_bar,
style=style_outer,
onclick=onclick)
def render(self):
# row info for the table
rr = []
sdkeys = self._context.sorterDefinitionKeys()
for sdkey in sdkeys:
sdef = self._context.sorterDefinition(sdkey)
rr.append(
dict(label=sdkey, value=vd.pre(json.dumps(sdef, indent=4))))
rows = []
for r in rr:
rows.append(vd.tr(vd.th(r['label']), vd.td(r['value'])))
table = vd.table(rows,
style={
'text-align': 'left',
'width': 'auto',
'font-size': '13px'
},
class_='table')
return vd.components.ScrollArea(
vd.div(vd.h2('Sorter definitions for analysis: {}'.format(
self._context.analysisName())),
table,
height=self._size[1]))
def __init__(self, group):
vd.Component.__init__(self)
self._group = group
SF = sf.SFData()
a = kb.loadObject(
key=dict(name='spikeforest_batch_group', group_name=group))
for recordings_name in a['recordings_names']:
try:
SF.loadRecordings(key=dict(name=recordings_name))
except:
raise
print('Warning: unable to load recordings: ' + recordings_name)
for batch_name in a['batch_names']:
try:
SF.loadProcessingBatch(batch_name=batch_name)
except:
print('Warning: unable to load processing batch: ' +
batch_name)
self._SF_data = SF
self._accuracy_threshold_input = vd.components.LineEdit(
value=0.8, dtype=float, style=dict(width='70px'))
self._update_button = vd.components.Button(onclick=self._on_update,
class_='button',
label='Update')
self._study_sorter_fig = StudySorterFigure(SF)
self._study_sorter_table = vd.div() # dummy
vd.devel.loadBootstrap()
self._update_accuracy_table()
def render(self):
list = [self._group_select_widget]
if self._sf_browser:
list.append(self._sf_browser)
return vd.div(
list
)
def render(self):
rows = []
rows.append(
vd.tr(vd.th('Unit ID'), vd.th('SNR'), vd.th('Peak channel'),
vd.th('Num. events'), vd.th('Firing rate')))
if self._true_units_info:
for unit in self._true_units_info:
rows.append(
vd.tr(vd.td(str(unit['unit_id'])), vd.td(str(unit['snr'])),
vd.td(str(unit['peak_channel'])),
vd.td(str(unit['num_events'])),
vd.td(str(unit['firing_rate']))))
else:
print('WARNING: true units info not found.')
table = vd.table(rows, class_='table')
return vd.div(ScrollArea(vd.div(table), height=400))
def render(self):
if self._error_message:
return vd.div(self._error_message)
box_style = dict(float='left')
boxes = [
vd.div(W, style=box_style) for W in [
self._true_unit_waveform_widget,
self._sorted_unit_waveform_widget,
self._unmatched_true_unit_waveform_widget,
self._unmatched_sorted_unit_waveform_widget
]
]
div = vd.div(
vd.h3('True unit {}, Sorted unit {}'.format(
self._true_unit_id, self._sorted_unit_id)), vd.div(boxes))
return ScrollArea(div, size=self._size)
def render(self):
button_style = {'margin': '3px'}
buttons = [
vd.button(item[0], onclick=item[1], style=button_style)
for item in self._data
]
return vd.div(buttons, style={'padding-bottom': '20px'})
def render(self):
style = dict(overflow='auto')
if self._width:
style['width'] = '{}px'.format(self._width)
if self._height:
style['height'] = '{}px'.format(self._height)
return vd.div(self._child, style=style)
def render(self):
list = [self._select_widget]
if self._explorer:
list.append(self._explorer)
return vd.div(
list
)
def render(self):
print('rendering timeserieswidget...')
div = vd.div(id=self._div_id)
js = """
console.log('testing 111');
function _base64ToArrayBuffer(base64) {
var binary_string = window.atob(base64);
var len = binary_string.length;
var bytes = new Uint8Array( len );
for (var i = 0; i < len; i++) {
bytes[i] = binary_string.charCodeAt(i);
}
return bytes.buffer;
}
let W=new window.TimeseriesWidget();
//W.setTimeseriesModel(new window.TestTimeseriesModel());
let X=_base64ToArrayBuffer(window.sfdata['array_b64_{div_id}']);
let A=new window.Mda();
A.setFromArrayBuffer(X);
let TS=new window.TimeseriesModel(A);
W.setTimeseriesModel(TS);
W.setSize({width},{height})
$('#{div_id}').empty();
$('#{div_id}').css({width:'{width}px',height:'{height}px'})
$('#{div_id}').append(W.element());
"""
js = self._div_id.join(js.split('{div_id}'))
js = js.replace('{width}', str(self._size[0]))
js = js.replace('{height}', str(self._size[1]))
js = '{}'.format(self._recording.getSamplingFrequency()).join(
js.split('{samplerate}'))
vd.devel.loadJavascript(js=js, delay=1)
return div
def render(self):
f = self._current_frame
style0 = dict(width='100%', height='100%', position='absolute')
style1 = dict(left='5px',
right='5px',
top='5px',
bottom='5px',
position='absolute')
onclick = self._on_click
if not f:
style1['background-color'] = 'lightgray'
f = ''
return vd.div(self._highlight_box,
vd.div(f, style=style1),
self._tab_bar,
style=style0,
onclick=onclick)
def render(self):
rows = []
rows.append(
vd.tr(vd.th('Unit ID'), vd.th('Accuracy'), vd.th('Best unit'),
vd.th('Matched unit'), vd.th('Num. matches'),
vd.th('False negative rate'), vd.th('False positive rate')))
for ii in self._comparison_info:
unit = self._comparison_info[ii]
rows.append(
vd.tr(vd.td(str(unit['unit_id'])),
vd.td(str(unit['accuracy'])),
vd.td(str(unit['best_unit'])),
vd.td(str(unit['matched_unit'])),
vd.td(str(unit['num_matches'])), vd.td(str(unit['f_n'])),
vd.td(str(unit['f_p']))))
table = vd.table(rows, class_='table')
return vd.div(ScrollArea(vd.div(table), height=400))
def render(self):
style = self._style
style['position'] = self._position_mode
style['width'] = '{}px'.format(self._size[0])
style['height'] = '{}px'.format(self._size[1])
style['left'] = '{}px'.format(self._position[0])
style['top'] = '{}px'.format(self._position[1])
return vd.div(self._children, style=style)
def render(self):
rec = self._context.recording
res = self._context.sorting_result
rows = []
rows.append(vd.tr(vd.th('Study'), vd.td(rec.study().name())))
rows.append(vd.tr(vd.th('Recording'), vd.td(rec.name())))
rows.append(vd.tr(vd.th('Directory'), vd.td(rec.directory())))
true_units = rec.trueUnitsInfo(format='json')
rows.append(
vd.tr(vd.th('Num. true units'),
vd.td('{}'.format(len(true_units)))))
RX = rec.recordingExtractor()
rows.append(
vd.tr(vd.th('Num. channels'),
vd.td('{}'.format(len(RX.getChannelIds())))))
rows.append(
vd.tr(vd.th('Samplerate'),
vd.td('{}'.format(RX.getSamplingFrequency()))))
recording_file_is_local = rec.recordingFileIsLocal()
if recording_file_is_local:
elmt = 'True'
else:
elmt = vd.span(
'False', ' ',
vd.a('(download)', onclick=self._on_download_recording_file))
rows.append(vd.tr(vd.th('raw.mda is downloaded'), vd.td(elmt)))
firings_true_file_is_local = rec.firingsTrueFileIsLocal()
if firings_true_file_is_local:
elmt = 'True'
else:
elmt = vd.span(
'False', ' ',
vd.a('(download)',
onclick=self._on_download_firings_true_file))
rows.append(vd.tr(vd.th('firings_true.mda is downloaded'),
vd.td(elmt)))
if res:
rows.append(vd.tr(vd.th('Sorting result'),
vd.td(res.sorterName())))
sorting = res.sorting()
rows.append(
vd.tr(vd.th('Num. sorted units'),
vd.td('{}'.format(len(sorting.getUnitIds())))))
table = vd.table(rows,
style={
'text-align': 'left',
'width': 'auto',
'font-size': '13px'
},
class_='table')
return ScrollArea(vd.div(table), size=self._size)
def render(self):
rows = [
vd.tr(vd.td('Select a group:'), vd.td(self._SEL_group)),
]
select_table = vd.table(
rows, style={'text-align': 'left', 'width': 'auto'}, class_='table')
return vd.div(
select_table
)
