def kde1d(datatable, marker, min_x=None, max_x=None):
def cached(data):
if type(datatable) is np.ndarray:
points = datatable
else:
points = datatable.get_cols(marker)[0]
range = np.max(points) - np.min(points)
min_x_ = min_x
max_x_ = max_x
if min_x == None:
min_x_ = np.min(points) - range / 10
if max_x == None:
max_x_ = np.max(points) + range / 10
from mlabwrap import mlab
data.bandwidth, data.density, data.xmesh = mlab.kde(
points, 2**12, min_x_, max_x_, nout=3)
data.xmesh = data.xmesh[0]
#print 'den:' + str(np.shape(data.density[0]))
data.density = data.density.T[0]
if type(datatable) is np.ndarray:
data = services.cache((None, marker, min_x, max_x), cached, False, False)
else:
data = services.cache((datatable, marker, min_x, max_x), cached, False, False)
display_graph(data.xmesh, data.density)
def color_table(datatable, dim_x=None, dim_y=None):
def cache(data):
ax = services.get_ax()
Picker(ax, datatable.dims)
ax = services.get_ax()
services.cache(ax, cache, True, False)
#print dim_x
#print dim_y
display_matrix(datatable.data, cmap=cm.jet)
ax.set_xticks(np.arange(len(datatable.dims)))
ax.set_yticks(np.arange(-1, len(datatable.dims)+1))
ax.set_xticklabels(datatable.dims)
ax.set_yticklabels([''] + datatable.dims)
ylabels = ax.yaxis.get_ticklabels()
xlabels = ax.xaxis.get_ticklabels()
for i in xrange(len(ylabels)):
x_index = i-1
ylabels[i].set_fontsize('xx-small')
if ylabels[i].get_text() == dim_y:
ylabels[i].set_weight('bold')
else:
ylabels[i].set_weight('normal')
if x_index >=0 and x_index < len(xlabels):
xlabels[x_index].set_fontsize('xx-small')
if ylabels[i].get_text() == dim_x :
xlabels[x_index].set_weight('bold')
else:
xlabels[x_index].set_weight('normal')
xlabels[x_index].set_rotation(90)
#ax.update_params(left=0, bottom=0)
ax.figure.canvas.draw()
return (dim_x, dim_y)
def kde1d(datatable, marker, min_x=None, max_x=None):
def cached(data):
if type(datatable) is np.ndarray:
points = datatable
else:
points = datatable.get_cols(marker)[0]
range = np.max(points) - np.min(points)
min_x_ = min_x
max_x_ = max_x
if min_x == None:
min_x_ = np.min(points) - range / 10
if max_x == None:
max_x_ = np.max(points) + range / 10
from mlabwrap import mlab
data.bandwidth, data.density, data.xmesh = mlab.kde(points,
2**12,
min_x_,
max_x_,
nout=3)
data.xmesh = data.xmesh[0]
#print 'den:' + str(np.shape(data.density[0]))
data.density = data.density.T[0]
if type(datatable) is np.ndarray:
data = services.cache((None, marker, min_x, max_x), cached, False,
False)
else:
data = services.cache((datatable, marker, min_x, max_x), cached, False,
False)
display_graph(data.xmesh, data.density)
def get_mutual_information(self, ignore_negative_values=True):
def cache(data):
from mlabwrap import mlab
bad_dims = self.get_markers('surface_ignore')
bad_dims.append('Cell Length')
bad_dims.append('Time')
bad_dims.append('191-DNA')
bad_dims.append('cluster_name')
bad_dims.append('stim')
bad_dims.append('cluster_num')
dims_to_use = self.dims[:]
dims_to_use = [d for d in dims_to_use if not d in bad_dims]
num_dims = len(dims_to_use)
res = np.zeros((num_dims, num_dims))
for i in xrange(num_dims):
for j in xrange(i):
logging.info('Calculating mutual information between %s and %s' % (dims_to_use[i], dims_to_use[j]))
arr = self.get_points(dims_to_use[i], dims_to_use[j])
if ignore_negative_values:
arr = arr[np.all(arr > 0, axis=1)]
if arr.shape[0] < 100:
services.print_text('Less than 100 cells in MI calculation for (%s, %s)' % (dims_to_use[i], dims_to_use[j]), weight=700, foreground='red')
res[j,i] = 0
res[i,j] = 0
continue
#print arr.shape
res[i,j] = mlab.mutualinfo_ap(arr, nout=1)
res[j,i] = 0
data.res = DataTable(res, dims_to_use)
data = services.cache((self,ignore_negative_values), cache, False, False)
return data.res
def display_graph(x_vals,
y_vals,
x_min=None,
x_max=None,
y_min=None,
y_max=None):
def create_data(data):
data.ax = services.get_ax()
data.line, = data.ax.plot([0], [0])
data.predefined_axes = False
if not None in (x_min, x_max, y_min, y_max):
data.predefined_axes = True
data.ax.set_xlim(x_min, x_max)
data.ax.set_ylim(y_min, y_max)
def update_widget(data):
#if self.line:
# self.line.remove()
#self.line, = self.ax.plot(x_vals, y_vals)
data.line.set_xdata(x_vals)
data.line.set_ydata(y_vals)
if not data.predefined_axes:
data.ax.set_xlim(min(x_vals), max(x_vals))
data.ax.set_ylim(min(y_vals), max(y_vals))
#self.ax.plot(x_vals, y_vals)
data.ax.figure.canvas.draw()
#draw?
data = services.cache((x_min, x_max, y_min, y_max), create_data, True,
False)
gobject.idle_add(update_widget, data)
def arcsinh_transform(self):
def cache(data):
data_copy = np.copy(self.data)
data_copy = np.arcsinh(data_copy)
data.table = DataTable(data_copy, self.dims)
data = services.cache(self, cache, False, False)
return data.table
def kde2d(datatable,
markers,
range,
title=None,
norm_axis=None,
norm_axis_thresh=0.1,
*args,
**kargs):
ax = services.get_ax()
#markers = biology.markers.normalize_markers(markers)
def cached(data):
from mlabwrap import mlab
a, w = datatable.get_cols(markers[0], markers[1])
if range:
min_a = range[0]
max_a = range[2]
min_w = range[1]
max_w = range[3]
else:
min_w = min(w)
max_w = max(w)
min_a = min(a)
max_a = max(a)
points = datatable.get_points(markers[0], markers[1])
bandwidth, data.density, data.X, data.Y = mlab.kde2d(points,
256,
[[min_a, min_w]],
[[max_a, max_w]],
nout=4)
data = services.cache((datatable, markers, range, args, kargs), cached,
True, False)
display_data = data.density
if norm_axis == 'x':
max_dens_x = np.array([np.max(data.density, axis=1)]).T
if norm_axis_thresh:
max_dens_x[max_dens_x < norm_axis_thresh] = np.inf
data.density_x = data.density / max_dens_x
display_data = data.density_x
elif norm_axis == 'y':
max_dens_y = np.array([np.max(data.density, axis=0)])
if norm_axis_thresh:
max_dens_y[max_dens_y < norm_axis_thresh] = np.inf
data.density_y = data.density / max_dens_y
display_data = data.density_y
if title:
data.ax.set_title(title)
ax.set_xlabel(str(markers[0]) + ' ')
ax.set_ylabel(str(markers[1]) + ' ')
display_image(
display_data,
origin='lower',
extent=[data.X[0, 0], data.X[0, -1], data.Y[0, 0], data.Y[-1, 0]],
interpolation=None,
*args,
**kargs)
ax.figure.canvas.draw()
def load_table(filename, selected_tags, expanded_titles):
filename = file_control(filename)
def cache(data):
if filename and filename.endswith('.index'):
data.index = DataIndex.load(filename)
else:
data.index = None
data = services.cache(filename, cache)
if data.index:
choice, picker, label = multi_picker_control(
selected_tags or [[],[],[]],
['Stims', 'Named Clusters', 'Clusters'],
expanded_titles or [False, False, False],
[
data.index.all_values_for_tag('stim'),
data.index.all_values_for_tag('cluster_name'),
data.index.all_values_for_tag('cluster_num')],
control_title='Stim/Cluster')
def predicate(tags):
if not selected_tags:
return False
test0 = 'stim' in tags and tags['stim'] in selected_tags[0]
test1 = 'cluster_name' in tags and tags['cluster_name'] in selected_tags[1]
test2 = 'cluster_num' in tags and tags['cluster_num'] in selected_tags[2]
return test0 and test1 and test2
return data.index.load_table(predicate)
else:
choice = multi_picker_control(
[[]], ['a'], [False], [[]], control_title='Stim/Cluster', hidden=True)
return load_data_table(filename)
def display_image(Z, extent, *args, **kargs):
def create_data(data):
#logging.info('yoooo')
data.ax = services.get_ax()
#from matplotlib.colors import LightSource
#ls = LightSource(azdeg=0,altdeg=65)
#rgb = ls.shade(Z, cm.jet)
data.image = data.ax.imshow(Z, extent=extent, *args, **kargs)
data.colorbar = data.ax.figure.colorbar(data.image)
data.ax.set_aspect('auto')
def update_gui(data):
#from matplotlib.colors import LightSource
#ls = LightSource(azdeg=0,altdeg=65)
#rgb = ls.shade(Z, cm.jet)
data.image.set_extent(extent)
data.image.set_data(Z)
#print data.image.get_clim()
data.image.autoscale()
data.colorbar.update_bruteforce(data.image)
#print data.image.get_clim()
data.ax.figure.canvas.draw()
data = services.cache((args, kargs), create_data, True, False)
update_gui(data)
def display_image(Z, extent, *args, **kargs):
def create_data(data):
#logging.info('yoooo')
data.ax = services.get_ax()
#from matplotlib.colors import LightSource
#ls = LightSource(azdeg=0,altdeg=65)
#rgb = ls.shade(Z, cm.jet)
data.image = data.ax.imshow(Z, extent=extent, *args, **kargs)
data.colorbar = data.ax.figure.colorbar(data.image)
data.ax.set_aspect('auto')
def update_gui(data):
#from matplotlib.colors import LightSource
#ls = LightSource(azdeg=0,altdeg=65)
#rgb = ls.shade(Z, cm.jet)
data.image.set_extent(extent)
data.image.set_data(Z)
#print data.image.get_clim()
data.image.autoscale()
data.colorbar.update_bruteforce(data.image)
#print data.image.get_clim()
data.ax.figure.canvas.draw()
data = services.cache((args, kargs), create_data, True, False)
update_gui(data)
def gate(x_marker, y_marker, rect, color_marker=None, datatable=None):
ax = services.get_ax()
def gate_cache(data):
ax = services.get_ax()
all_markers = None
if datatable:
all_markers = datatable.dims
data.text = ax.figure.text(0.01, 0.01, '', picker=1, size='x-small')
data.gater = Gater(ax, all_markers, rect, data.text)
data = services.cache((ax), gate_cache, True, False)
ax.set_xlabel(x_marker)
ax.set_ylabel(y_marker)
if color_marker:
data.text.set_text('Color: %s' % str(color_marker))
data.gater.renew_rect(rect)
if not rect:
rect = [None, None, None, None]
dim_ranges = [
DimRange(x_marker, rect[0], rect[2]),
DimRange(y_marker, rect[1], rect[3])
]
#if title:
# data.ax.set_title(title)
return (dim_ranges, x_marker, y_marker, rect, color_marker)
def display_text(text):
def create_data(data):
data.widget = gtk.Label()
services.add_widget_in_current_location(data.widget)
data = services.cache(None, create_data, True, True)
gobject.idle_add(data.widget.set_text, text)
def gate(x_marker, y_marker, rect, color_marker=None, datatable=None):
ax = services.get_ax()
def gate_cache(data):
ax = services.get_ax()
all_markers = None
if datatable:
all_markers = datatable.dims
data.text = ax.figure.text(0.01, 0.01, '', picker=1, size='x-small')
data.gater = Gater(ax, all_markers, rect, data.text)
data = services.cache((ax), gate_cache, True, False)
ax.set_xlabel(x_marker)
ax.set_ylabel(y_marker)
if color_marker:
data.text.set_text('Color: %s' % str(color_marker))
data.gater.renew_rect(rect)
if not rect:
rect = [None, None, None, None]
dim_ranges = [
DimRange(x_marker, rect[0], rect[2]),
DimRange(y_marker, rect[1], rect[3])]
#if title:
# data.ax.set_title(title)
return (dim_ranges, x_marker, y_marker, rect, color_marker)
def text_control(text, title='Description'):
def cache(data):
data.text_label = gtk.Label(text)
data.text_label.set_alignment(0, 0)
data.text_label.set_size_request(250,-1)
data.text_label.set_line_wrap(True)
data.title_label = services.add_widget_in_control_box(title, data.text_label)
data = services.cache(None, cache, False, True)
data.title_label.set_markup('<b>%s</b>' % title)
data.text_label.set_label(text)
return text
def scatter(datatable, markers, range=None, color_marker=None, min_cells_per_bin=1, no_bins=512j, *args, **kargs):
def cached(data):
cols = datatable.get_cols(*markers)
if not range:
fixed_range = [
min(cols[0]),
min(cols[1]),
max(cols[0]),
max(cols[1])]
else:
fixed_range = range
hist, data.x_edges, data.y_edges = np.histogram2d(
cols[0],
cols[1],
[
np.r_[fixed_range[0]:fixed_range[2]:no_bins],
np.r_[fixed_range[1]:fixed_range[3]:no_bins]])
data.final_hist = np.sign(np.subtract(
np.clip(np.abs(hist), min_cells_per_bin, np.inf),
min_cells_per_bin))
if color_marker:
data.is_colored = True
weights = datatable.get_cols(color_marker)[0]
weighted_hist, x_edges, y_edges = np.histogram2d(
cols[0],
cols[1],
[
np.r_[fixed_range[0]:fixed_range[2]:no_bins],
np.r_[fixed_range[1]:fixed_range[3]:no_bins]], None, False, weights)
data.colored_hist = np.multiply(
np.true_divide(weighted_hist, hist), data.final_hist)
else:
data.is_colored = False
data = services.cache((datatable, markers, range, color_marker, args, kargs), cached, True, False)
if data.is_colored:
data_to_draw = data.colored_hist
cmap = cm.jet
else:
data_to_draw = data.final_hist
cmap = cm.gist_yarg
controls.display_image(
data_to_draw.T, origin='lower',
extent=[
data.x_edges[0],
data.x_edges[-1],
data.y_edges[0],
data.y_edges[-1]],
interpolation=None,
cmap=cmap, *args, **kargs)
def gate(self, *dim_ranges):
def gate_cache(data):
relevant_data = self.get_points(*[r.dim for r in dim_ranges])
mins = np.array([r.min for r in dim_ranges])
maxes = np.array([r.max for r in dim_ranges])
test1 = np.alltrue(relevant_data >= mins, axis=1)
test2 = np.alltrue(relevant_data <= maxes, axis=1)
final = np.logical_and(test1, test2)
data.table = DataTable(self.data[final], self.dims)
data = services.cache((self, dim_ranges), gate_cache, False, False)
return data.table
def combine_tables(datatables):
def cache(data):
print '~!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
print datatables
assert len(datatables)
assert all([datatables[0].dims == t.dims for t in datatables])
new_data = np.concatenate([t.data for t in datatables])
data.new_table = DataTable(
new_data, datatables[0].dims, datatables[0].legends)
data = services.cache((datatables), cache, False, False)
return data.new_table
def gate2(self, *dim_ranges):
def kd_tree_cache(data):
points = self.get_points(*[r.dim for r in dim_ranges])
data.tree = KDTree(points)
global services
data = services.cache((self, [r.dim for r in dim_ranges]), kd_tree_cache, False, False)
rect = Rectangle(
[r.min for r in dim_ranges],
[r.max for r in dim_ranges])
new_indices = data.tree.query_range(rect)
return DataTable(self.data[new_indices], self.dims)
def display_matrix(Z, *args, **kargs):
def create_data(data):
data.ax = services.get_ax()
data.image = data.ax.matshow(Z, *args, **kargs)
def update_gui(data):
data.image.set_data(Z)
data.image.autoscale()
data.ax.figure.canvas.draw()
data = services.cache((Z.shape, args, kargs), create_data, True, False)
update_gui(data)
def display_matrix(Z, *args, **kargs):
def create_data(data):
data.ax = services.get_ax()
data.image = data.ax.matshow(Z, *args, **kargs)
def update_gui(data):
data.image.set_data(Z)
data.image.autoscale()
data.ax.figure.canvas.draw()
data = services.cache((Z.shape, args, kargs), create_data, True, False)
update_gui(data)
def kde2d(datatable, markers, range, title=None, norm_axis=None, norm_axis_thresh = 0.1, *args, **kargs):
ax = services.get_ax()
#markers = biology.markers.normalize_markers(markers)
def cached(data):
from mlabwrap import mlab
a, w = datatable.get_cols(markers[0], markers[1])
if range:
min_a = range[0]
max_a = range[2]
min_w = range[1]
max_w = range[3]
else:
min_w = min(w)
max_w = max(w)
min_a = min(a)
max_a = max(a)
points = datatable.get_points(markers[0], markers[1])
bandwidth,data.density, data.X, data.Y = mlab.kde2d(
points, 256,
[[min_a, min_w]],
[[max_a, max_w]],
nout=4)
data = services.cache((datatable, markers, range, args, kargs), cached, True, False)
display_data = data.density
if norm_axis == 'x':
max_dens_x = np.array([np.max(data.density, axis=1)]).T
if norm_axis_thresh:
max_dens_x[max_dens_x < norm_axis_thresh] = np.inf
data.density_x = data.density / max_dens_x
display_data = data.density_x
elif norm_axis == 'y':
max_dens_y = np.array([np.max(data.density, axis=0)])
if norm_axis_thresh:
max_dens_y[max_dens_y < norm_axis_thresh] = np.inf
data.density_y = data.density / max_dens_y
display_data = data.density_y
if title:
data.ax.set_title(title)
ax.set_xlabel(str(markers[0]) + ' ')
ax.set_ylabel(str(markers[1]) + ' ')
display_image(
display_data,
origin='lower',
extent=[
data.X[0,0],
data.X[0,-1],
data.Y[0,0],
data.Y[-1,0]],
interpolation=None, *args, **kargs)
ax.figure.canvas.draw()
def dim_choose(x_marker, y_marker, datatable=None):
ax = services.get_ax()
def gate_cache(data):
ax = services.get_ax()
all_markers = None
if datatable:
all_markers = datatable.dims
data.gater = Gater(ax, all_markers, None, None, False, True)
data = services.cache((ax), gate_cache, True, False)
ax.set_ylabel(y_marker)
ax.set_xlabel(x_marker)
return (x_marker, y_marker)
def text_control(text, title='Description'):
def cache(data):
data.text_label = gtk.Label(text)
data.text_label.set_alignment(0, 0)
data.text_label.set_size_request(250, -1)
data.text_label.set_line_wrap(True)
data.title_label = services.add_widget_in_control_box(
title, data.text_label)
data = services.cache(None, cache, False, True)
data.title_label.set_markup('<b>%s</b>' % title)
data.text_label.set_label(text)
return text
def gate2(self, *dim_ranges):
""" Gating using kd-tree, deprecated do not use
"""
def kd_tree_cache(data):
points = self.get_points(*[r.dim for r in dim_ranges])
data.tree = KDTree(points)
global services
data = services.cache((self, [r.dim for r in dim_ranges]), kd_tree_cache)
rect = Rectangle(
[r.min for r in dim_ranges],
[r.max for r in dim_ranges])
new_indices = data.tree.query_range(rect)
return DataTable(self.data[new_indices], self.dims)
def dim_color_choose(x_marker, y_marker, color_marker, datatable=None):
ax = services.get_ax()
def gate_cache(data):
ax = services.get_ax()
all_markers = None
if datatable:
all_markers = datatable.dims
data.text = ax.figure.text(0.01, 0.01, '', picker=1, size='x-small')
data.gater = Gater(ax, all_markers, None, data.text, False, True)
data = services.cache((ax), gate_cache, True, False)
ax.set_ylabel(y_marker)
ax.set_xlabel(x_marker)
data.text.set_text('Color: %s' % str(color_marker))
return (x_marker, y_marker, color_marker)
def windowed_medians(self, progression_dim, window_size=1000, overlap=500):
window_size = int(window_size)
overlap = int(overlap)
def cache(data):
# first sort by the given dim:
xdim_index = self.dims.index(progression_dim)
sorted_data = self.data[self.data[:,xdim_index].argsort(),]
# create windows:
from segmentaxis import segment_axis
seg_data = segment_axis(sorted_data, window_size, overlap, axis=0)
med_data = np.median(seg_data, axis=1)
data.table = DataTable(med_data, self.dims)
data = services.cache((self, progression_dim, window_size, overlap), cache, False, False)
return data.table
def dim_choose(x_marker, y_marker, datatable=None):
ax = services.get_ax()
def gate_cache(data):
ax = services.get_ax()
all_markers = None
if datatable:
all_markers = datatable.dims
data.gater = Gater(ax, all_markers, None, None, False, True)
data = services.cache((ax), gate_cache, True, False)
ax.set_ylabel(y_marker)
ax.set_xlabel(x_marker)
return (x_marker, y_marker)
def color_table(datatable, dim_x=None, dim_y=None):
def cache(data):
ax = services.get_ax()
Picker(ax, datatable.dims)
ax = services.get_ax()
services.cache(ax, cache, True, False)
#print dim_x
#print dim_y
display_matrix(datatable.data, cmap=cm.jet)
ax.set_xticks(np.arange(len(datatable.dims)))
ax.set_yticks(np.arange(-1, len(datatable.dims) + 1))
ax.set_xticklabels(datatable.dims)
ax.set_yticklabels([''] + datatable.dims)
ylabels = ax.yaxis.get_ticklabels()
xlabels = ax.xaxis.get_ticklabels()
for i in xrange(len(ylabels)):
x_index = i - 1
ylabels[i].set_fontsize('xx-small')
if ylabels[i].get_text() == dim_y:
ylabels[i].set_weight('bold')
else:
ylabels[i].set_weight('normal')
if x_index >= 0 and x_index < len(xlabels):
xlabels[x_index].set_fontsize('xx-small')
if ylabels[i].get_text() == dim_x:
xlabels[x_index].set_weight('bold')
else:
xlabels[x_index].set_weight('normal')
xlabels[x_index].set_rotation(90)
#ax.update_params(left=0, bottom=0)
ax.figure.canvas.draw()
return (dim_x, dim_y)
def dim_color_choose(x_marker, y_marker, color_marker, datatable=None):
ax = services.get_ax()
def gate_cache(data):
ax = services.get_ax()
all_markers = None
if datatable:
all_markers = datatable.dims
data.text = ax.figure.text(0.01, 0.01, '', picker=1, size='x-small')
data.gater = Gater(ax, all_markers, None, data.text, False, True)
data = services.cache((ax), gate_cache, True, False)
ax.set_ylabel(y_marker)
ax.set_xlabel(x_marker)
data.text.set_text('Color: %s' % str(color_marker))
return (x_marker, y_marker, color_marker)
def slider_control(val, min_val, max_val, title='Number'):
def cache(data):
def button_release(range, event, changer):
changer.set_parameter(0, range.get_value())
services.replay_script()
data.slider = gtk.HScale()
data.slider.set_value_pos(gtk.POS_LEFT)
data.slider.set_range(min_val, max_val)
data.slider.connect(
'button-release-event', button_release, services.get_current_changer())
#data.slider.set_size_request(150,-1)
data.title_label = services.add_widget_in_control_box(title, data.slider)
data = services.cache(None, cache, False, True)
data.title_label.set_markup('<b>%s</b>' % title)
data.slider.set_value(val)
return val
def picker_control(choice, options, title='Choice'):
def cache(data):
def changed(combobox, changer):
changer.set_parameter(0, repr(combobox.get_active_text()))
services.replay_script()
data.box = gtk.combo_box_new_text()
for option in options:
data.box.append_text(option)
data.handler_id = data.box.connect(
'changed', changed, services.get_current_changer())
#data.slider.set_size_request(150,-1)
data.title_label = services.add_widget_in_control_box(title, data.box)
data = services.cache(None, cache, False, True)
data.title_label.set_markup('<b>%s</b>' % title)
if choice in options:
data.box.handler_block(data.handler_id)
data.box.set_active(options.index(choice))
data.box.handler_unblock(data.handler_id)
return choice
def slider_control(val, min_val, max_val, title='Number'):
def cache(data):
def button_release(range, event, changer):
changer.set_parameter(0, range.get_value())
services.replay_script()
data.slider = gtk.HScale()
data.slider.set_value_pos(gtk.POS_LEFT)
data.slider.set_range(min_val, max_val)
data.slider.connect('button-release-event', button_release,
services.get_current_changer())
#data.slider.set_size_request(150,-1)
data.title_label = services.add_widget_in_control_box(
title, data.slider)
data = services.cache(None, cache, False, True)
data.title_label.set_markup('<b>%s</b>' % title)
data.slider.set_value(val)
return val
def file_control(filename, title='Filename'):
def cache(data):
def button_click(button, changer):
new_file = file_dialog(title, filename and os.path.dirname(filename))
if new_file:
changer.set_parameter_by_name('filename', repr(new_file))
services.replay_script()
data.button = gtk.Button(label=filename)
data.button.set_size_request(250,-1)
data.button.connect('clicked', button_click, services.get_current_changer())
data.title_label = services.add_widget_in_control_box(title, data.button)
data = services.cache(None, cache, False, True)
data.title_label.set_markup('<b>%s</b>' % title)
if filename:
data.button.set_label(filename)
else:
data.button.set_label('No file selected')
#raise Exception('Missing filename')
return filename
def gatex(x_marker, y_text, rect, datatable=None):
ax = services.get_ax()
def gate_cache(data):
ax = services.get_ax()
all_markers = None
if datatable:
all_markers = datatable.dims
data.gater = Gater(ax, all_markers, rect, None, True)
data = services.cache((ax), gate_cache, True, False)
ax.set_xlabel(x_marker)
ax.set_ylabel(y_text)
data.gater.renew_rect(rect)
if not rect:
rect = [None, None]
dim_ranges = [DimRange(x_marker, rect[0], rect[1])]
return (dim_ranges, x_marker, rect)
def gatex(x_marker, y_text, rect, datatable=None):
ax = services.get_ax()
def gate_cache(data):
ax = services.get_ax()
all_markers = None
if datatable:
all_markers = datatable.dims
data.gater = Gater(ax, all_markers, rect, None, True)
data = services.cache((ax), gate_cache, True, False)
ax.set_xlabel(x_marker)
ax.set_ylabel(y_text)
data.gater.renew_rect(rect)
if not rect:
rect = [None, None]
dim_ranges = [DimRange(x_marker, rect[0], rect[1])]
return (dim_ranges, x_marker, rect)
def picker_control(choice, options, title='Choice'):
def cache(data):
def changed(combobox, changer):
changer.set_parameter(0, repr(combobox.get_active_text()))
services.replay_script()
data.box = gtk.combo_box_new_text()
for option in options:
data.box.append_text(option)
data.handler_id = data.box.connect('changed', changed,
services.get_current_changer())
#data.slider.set_size_request(150,-1)
data.title_label = services.add_widget_in_control_box(title, data.box)
data = services.cache(None, cache, False, True)
data.title_label.set_markup('<b>%s</b>' % title)
if choice in options:
data.box.handler_block(data.handler_id)
data.box.set_active(options.index(choice))
data.box.handler_unblock(data.handler_id)
return choice
def add_reduced_dims(self, method, no_dims, dims_to_use=None, *args, **kargs):
if not dims_to_use:
dims_to_use = self.dims
def add_reduced_dims_cache(data):
points = self.get_points(*dims_to_use)
from mlabwrap import mlab
extra_points, mapping = mlab.compute_mapping(
points, method, no_dims, *args, nout=2, **kargs)
if method.lower() in ['isomap', 'lle']:
# we need to convert the index array from matlab to python (and remember
# that python is 0-based and not 1-based)
indices = np.subtract(mapping.conn_comp.T[0].astype('int'), 1)
old_data = self.data[indices,:]
else:
old_data = self.data
new_data = np.concatenate((old_data, extra_points), axis=1)
extra_dims = ['%s%d' % (method, i) for i in xrange(no_dims)]
new_dims = self.dims + extra_dims
data.new_table = DataTable(new_data, new_dims)
global services
data = services.cache((self, method, no_dims, dims_to_use, args, kargs), add_reduced_dims_cache, False, False)
return data.new_table
def load_table(filename, selected_tags, expanded_titles):
filename = file_control(filename)
def cache(data):
if filename and filename.endswith('.index'):
data.index = DataIndex.load(filename)
else:
data.index = None
data = services.cache(filename, cache)
if data.index:
choice, picker, label = multi_picker_control(
selected_tags or [[], [], []],
['Stims', 'Named Clusters', 'Clusters'],
expanded_titles or [False, False, False], [
data.index.all_values_for_tag('stim'),
data.index.all_values_for_tag('cluster_name'),
data.index.all_values_for_tag('cluster_num')
],
control_title='Stim/Cluster')
def predicate(tags):
if not selected_tags:
return False
test0 = 'stim' in tags and tags['stim'] in selected_tags[0]
test1 = 'cluster_name' in tags and tags[
'cluster_name'] in selected_tags[1]
test2 = 'cluster_num' in tags and tags[
'cluster_num'] in selected_tags[2]
return test0 and test1 and test2
return data.index.load_table(predicate)
else:
choice = multi_picker_control([[]], ['a'], [False], [[]],
control_title='Stim/Cluster',
hidden=True)
return load_data_table(filename)
def display_graph(x_vals, y_vals, x_min=None, x_max=None, y_min=None, y_max=None):
def create_data(data):
data.ax = services.get_ax()
data.line, = data.ax.plot([0], [0])
data.predefined_axes = False
if not None in (x_min, x_max, y_min, y_max):
data.predefined_axes = True
data.ax.set_xlim(x_min, x_max)
data.ax.set_ylim(y_min, y_max)
def update_widget(data):
#if self.line:
# self.line.remove()
#self.line, = self.ax.plot(x_vals, y_vals)
data.line.set_xdata(x_vals)
data.line.set_ydata(y_vals)
if not data.predefined_axes:
data.ax.set_xlim(min(x_vals), max(x_vals))
data.ax.set_ylim(min(y_vals), max(y_vals))
#self.ax.plot(x_vals, y_vals)
data.ax.figure.canvas.draw()
#draw?
data = services.cache((x_min, x_max, y_min, y_max), create_data, True, False)
gobject.idle_add(update_widget, data)
def file_control(filename, title='Filename'):
def cache(data):
def button_click(button, changer):
new_file = file_dialog(title, filename
and os.path.dirname(filename))
if new_file:
changer.set_parameter_by_name('filename', repr(new_file))
services.replay_script()
data.button = gtk.Button(label=filename)
data.button.set_size_request(250, -1)
data.button.connect('clicked', button_click,
services.get_current_changer())
data.title_label = services.add_widget_in_control_box(
title, data.button)
data = services.cache(None, cache, False, True)
data.title_label.set_markup('<b>%s</b>' % title)
if filename:
data.button.set_label(filename)
else:
data.button.set_label('No file selected')
#raise Exception('Missing filename')
return filename
def display_text(text):
def create_data(data):
data.widget = gtk.Label()
services.add_widget_in_current_location(data.widget)
data = services.cache(None, create_data, True, True)
gobject.idle_add(data.widget.set_text, text)
def random_sample(self, n):
def random_sample_cache(data):
indices = random.sample(xrange(np.shape(self.data)[0]), n)
data.table = DataTable(self.data[indices], self.dims)
data = services.cache((self, n), random_sample_cache, False, False)
return data.table
def multi_picker_control(choices,
titles,
expanded_titles,
option_lists,
control_title='Multi Choice',
hidden=False):
def update_title_values(title_row_iter, data):
child_vals = [c[1] for c in title_row_iter.iterchildren()]
title_row_iter[1] = any(child_vals)
title_row_iter[2] = not all(child_vals) and any(child_vals)
title_row_index = int(title_row_iter.path[-1])
if all(child_vals):
extra_text = 'Any'
elif not any(child_vals):
extra_text = 'None'
else:
selected_children_text = [
c[0] for c in title_row_iter.iterchildren() if c[1]
]
extra_text = ', '.join(selected_children_text)
new_title = '%s: %s' % (data.titles[title_row_index], extra_text)
title_row_iter[0] = new_title
def cache(data):
def update_params(changer, data):
new_choices = []
for i in xrange(len(data.option_lists)):
choices_for_list = []
for j in xrange(len(data.option_lists[i])):
if (data.tree_store[(i, j)][1]):
choices_for_list.append(data.option_lists[i][j])
new_choices.append(choices_for_list)
expanded = [
data.tree_view.row_expanded((i))
for i in xrange(len(data.titles))
]
changer.set_parameter_by_name('choices', repr(new_choices))
changer.set_parameter_by_name('expanded_titles', repr(expanded))
changer.set_parameter_by_name('expanded_titles', repr(expanded))
def apply_clicked(button, data, changer):
update_params(changer, data)
services.replay_script()
def row_expanded_collapsed(treeview, iter, path, data, changer):
update_params(changer, data)
def row_toggled(cell, path, data, changer):
data.button.show()
parent = data.tree_store[path].parent
if parent:
data.tree_store[path][1] = not data.tree_store[path][1]
update_title_values(parent, data)
else:
new_val = not any([
child[1] for child in data.tree_store[path].iterchildren()
])
for child in data.tree_store[path].iterchildren():
child[1] = new_val
update_title_values(data.tree_store[path], data)
update_params(changer, data)
data.tree_store = gtk.TreeStore(gobject.TYPE_STRING,
gobject.TYPE_BOOLEAN,
gobject.TYPE_BOOLEAN)
data.tree_view = gtk.TreeView(data.tree_store)
data.tree_view.connect('row_expanded', row_expanded_collapsed, data,
services.get_current_changer())
data.tree_view.connect('row_collapsed', row_expanded_collapsed, data,
services.get_current_changer())
data.tree_view.set_headers_visible(False)
data.renderer_toggle = gtk.CellRendererToggle()
data.renderer_toggle.set_property('activatable', True)
data.renderer_toggle.connect('toggled', row_toggled, data,
services.get_current_changer())
data.renderer_text = gtk.CellRendererText()
data.renderer_text.set_property('wrap-width', 220)
data.column0 = gtk.TreeViewColumn("Item", data.renderer_text, text=0)
data.column1 = gtk.TreeViewColumn(
"Selected", data.renderer_toggle, active=1,
inconsistent=2) # TODO: add inconsistent here
#data.renderer_text.set_fixed_size(250,-1)
data.tree_view.append_column(data.column0)
data.tree_view.append_column(data.column1)
data.vbox = gtk.VBox()
data.vbox.pack_start(data.tree_view)
data.button = gtk.Button('Apply')
data.button.connect('clicked', apply_clicked, data,
services.get_current_changer())
data.vbox.pack_start(data.button)
data.tree_view.show()
data.vbox.show()
data.title_label = services.add_widget_in_control_box(
control_title, data.vbox)
data = services.cache(None, cache, False, True)
data.titles = titles
data.option_lists = option_lists
data.tree_store.clear()
for i in xrange(len(titles)):
child_vals = [text in choices[i] for text in option_lists[i]]
parent = data.tree_store.append(
None, ('', False,
False)) # we will set the values with update_title_values
for j in xrange(len(option_lists[i])):
text = option_lists[i][j]
data.tree_store.append(parent, (text, text in choices[i], False))
update_title_values(data.tree_store[parent], data)
if expanded_titles[i]:
data.tree_view.expand_row(data.tree_store[parent].path, True)
data.button.hide()
data.title_label.set_markup('<b>%s</b>' % control_title)
if hidden:
data.vbox.hide()
data.title_label.hide()
else:
data.vbox.show()
data.title_label.show()
return choices
def multi_picker_control(choices, titles, expanded_titles, option_lists, control_title='Multi Choice', hidden=False):
def update_title_values(title_row_iter, data):
child_vals = [c[1] for c in title_row_iter.iterchildren()]
title_row_iter[1] = any(child_vals)
title_row_iter[2] = not all(child_vals) and any(child_vals)
title_row_index = int(title_row_iter.path[-1])
if all(child_vals):
extra_text = 'Any'
elif not any(child_vals):
extra_text = 'None'
else:
selected_children_text = [c[0] for c in title_row_iter.iterchildren() if c[1]]
extra_text = ', '.join(selected_children_text)
new_title = '%s: %s' % (data.titles[title_row_index], extra_text)
title_row_iter[0] = new_title
def cache(data):
def update_params(changer, data):
new_choices = []
for i in xrange(len(data.option_lists)):
choices_for_list = []
for j in xrange(len(data.option_lists[i])):
if(data.tree_store[(i,j)][1]):
choices_for_list.append(data.option_lists[i][j])
new_choices.append(choices_for_list)
expanded = [data.tree_view.row_expanded((i)) for i in xrange(len(data.titles))]
changer.set_parameter_by_name('choices', repr(new_choices))
changer.set_parameter_by_name('expanded_titles', repr(expanded))
changer.set_parameter_by_name('expanded_titles', repr(expanded))
def apply_clicked(button, data, changer):
update_params(changer, data)
services.replay_script()
def row_expanded_collapsed(treeview, iter, path, data, changer):
update_params(changer, data)
def row_toggled(cell, path, data, changer):
data.button.show()
parent = data.tree_store[path].parent
if parent:
data.tree_store[path][1] = not data.tree_store[path][1]
update_title_values(parent, data)
else:
new_val = not any([child[1] for child in data.tree_store[path].iterchildren()])
for child in data.tree_store[path].iterchildren():
child[1] = new_val
update_title_values(data.tree_store[path], data)
update_params(changer, data)
data.tree_store = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN)
data.tree_view = gtk.TreeView(data.tree_store)
data.tree_view.connect('row_expanded', row_expanded_collapsed, data, services.get_current_changer())
data.tree_view.connect('row_collapsed', row_expanded_collapsed, data, services.get_current_changer())
data.tree_view.set_headers_visible(False)
data.renderer_toggle = gtk.CellRendererToggle()
data.renderer_toggle.set_property('activatable', True)
data.renderer_toggle.connect('toggled', row_toggled, data, services.get_current_changer())
data.renderer_text = gtk.CellRendererText()
data.renderer_text.set_property('wrap-width', 220)
data.column0 = gtk.TreeViewColumn("Item", data.renderer_text, text=0)
data.column1 = gtk.TreeViewColumn("Selected", data.renderer_toggle, active=1, inconsistent=2) # TODO: add inconsistent here
#data.renderer_text.set_fixed_size(250,-1)
data.tree_view.append_column(data.column0)
data.tree_view.append_column(data.column1)
data.vbox = gtk.VBox()
data.vbox.pack_start(data.tree_view)
data.button = gtk.Button('Apply')
data.button.connect('clicked', apply_clicked, data, services.get_current_changer())
data.vbox.pack_start(data.button)
data.tree_view.show()
data.vbox.show()
data.title_label = services.add_widget_in_control_box(control_title, data.vbox)
data = services.cache(None, cache, False, True)
data.titles = titles
data.option_lists = option_lists
data.tree_store.clear()
for i in xrange(len(titles)):
child_vals = [text in choices[i] for text in option_lists[i]]
parent = data.tree_store.append(
None, ('', False, False)) # we will set the values with update_title_values
for j in xrange(len(option_lists[i])):
text = option_lists[i][j]
data.tree_store.append(parent, (text, text in choices[i], False))
update_title_values(data.tree_store[parent], data)
if expanded_titles[i]:
data.tree_view.expand_row(data.tree_store[parent].path, True)
data.button.hide()
data.title_label.set_markup('<b>%s</b>' % control_title)
if hidden:
data.vbox.hide()
data.title_label.hide()
else:
data.vbox.show()
data.title_label.show()
return choices
def scatter(datatable,
markers,
range=None,
color_marker=None,
min_cells_per_bin=1,
no_bins=512j,
*args,
**kargs):
def cached(data):
cols = datatable.get_cols(*markers)
if not range:
fixed_range = [
min(cols[0]),
min(cols[1]),
max(cols[0]),
max(cols[1])
]
else:
fixed_range = range
hist, data.x_edges, data.y_edges = np.histogram2d(
cols[0], cols[1], [
np.r_[fixed_range[0]:fixed_range[2]:no_bins],
np.r_[fixed_range[1]:fixed_range[3]:no_bins]
])
data.final_hist = np.sign(
np.subtract(np.clip(np.abs(hist), min_cells_per_bin, np.inf),
min_cells_per_bin))
if color_marker:
data.is_colored = True
weights = datatable.get_cols(color_marker)[0]
weighted_hist, x_edges, y_edges = np.histogram2d(
cols[0], cols[1], [
np.r_[fixed_range[0]:fixed_range[2]:no_bins],
np.r_[fixed_range[1]:fixed_range[3]:no_bins]
], None, False, weights)
data.colored_hist = np.multiply(
np.true_divide(weighted_hist, hist), data.final_hist)
else:
data.is_colored = False
data = services.cache(
(datatable, markers, range, color_marker, args, kargs), cached, True,
False)
if data.is_colored:
data_to_draw = data.colored_hist
cmap = cm.jet
else:
data_to_draw = data.final_hist
cmap = cm.gist_yarg
controls.display_image(data_to_draw.T,
origin='lower',
extent=[
data.x_edges[0], data.x_edges[-1],
data.y_edges[0], data.y_edges[-1]
],
interpolation=None,
cmap=cmap,
*args,
**kargs)
