def __init__ (self,**kwargs):
self.datapath=sum_data_path
self.pck_open_name='summary_data.pck'
self.sumdt=fh.open_pickle(self.pck_open_name)['sumdt']
self.adt=fh.open_pickle(self.pck_open_name)['adt']
def make_plots(self):
self.exec_file = os.path.abspath(__file__)
self.python_directory = os.path.split(self.exec_file)[0]
self.datapath = path['sum_data_path'] + 'summary_data/'
self.pck_open_name = 'vecstrength_unpaired_sumsundata.pck'
self.datapath = path['input_data_path'] + 'summary_data/'
self.sumdt = fh.open_pickle(self.datapath +
self.pck_open_name)['sumdt']
for data_type_ind, crflytype in enumerate(FLY_TYPE_TO_SAVE):
motor_offset = OFFSET_TO_SUBTRACT[data_type_ind]
self.crindtype = IND_TYPE_TO_SAVE[data_type_ind]
self.csv_ind = 0
flyinds = self.sumdt[crflytype]
for self.crflynum in flyinds:
self.get_fly_data(self.crflynum)
if self.crdt:
for crind in np.arange(len(self.crdt)):
#0 is index for first sun flight
#1 is index for second sun flight
#2 is index for stripe flight
self.add_to_cr_csv(crind=crind)
def process_data_by_fly(self):
self.datvls = {}
files = sorted(os.listdir(self.in_data_path))
self.exec_file = os.path.abspath(__file__)
self.txtfiles = sorted([f for f in files if f[-3:] == 'txt'])
self.crdt = {}
for self.crfile in self.txtfiles:
self.get_data_by_file()
if self.params:
try:
self.datpath = self.raw_save_file_name
self.crdt = fh.open_pickle(self.datpath)
self.pckname = self.in_data_path + str(
self.fname) + '_rawdata.pck'
except:
self.pckname = []
print 'no pickle'
else:
#pdb.set_trace()
self.crdt = {}
self.pckname = []
print 'no pickle'
self.make_example_figure()
def make_image():
fig=plt.figure(figsize=(1,2))
ax=fig.add_subplot(111)
plt.set_cmap('viridis')
crfile=files_to_plot[0]
dt=fh.open_pickle(data_path+crfile+'.pck')
ax.imshow(dt['im_mean'],origin='lower')
plt.sca(ax)
cr_roi=dt['roi'][roi_ind]
cr_roi.display_roi()
ax.set_ylim(10,70)
ax.set_xlim(20,90)
ten_microns_in_pixels=10/microns_per_pixel
plt.plot([30,30+ten_microns_in_pixels],[20,20],'r')
cr_center=on_target_centers[0]
circ=plt.Circle((cr_center[0],cr_center[1]),radius=5/microns_per_pixel,edgecolor='k',facecolor='None')
ax.add_patch(circ)
cr_center=on_target_centers[1]
circ=plt.Circle((cr_center[0],cr_center[1]),radius=5/microns_per_pixel,edgecolor='k',facecolor='None')
ax.add_patch(circ)
cr_center=off_target_centers[0]
circ=plt.Circle((cr_center[0],cr_center[1]),radius=5/microns_per_pixel,edgecolor='r',facecolor='None')
ax.add_patch(circ)
cr_center=off_target_centers[1]
circ=plt.Circle((cr_center[0],cr_center[1]),radius=5/microns_per_pixel,edgecolor='r',facecolor='None')
ax.add_patch(circ)
fpl.adjust_spines(ax,[])
def make_traces():
fig = plt.figure(figsize=(1.5, 1.5))
gs = GridSpec(2, 2, figure=fig)
ax = {}
ax['on'] = []
ax['off'] = []
ax['on'].append(fig.add_subplot(gs[0, 0]))
ax['on'].append(fig.add_subplot(gs[1, 0]))
ax['off'].append(fig.add_subplot(gs[0, 1]))
ax['off'].append(fig.add_subplot(gs[1, 1]))
for crind, crfile in enumerate(files_to_plot):
dt = fh.open_pickle(data_path + crfile + '.pck')
pdb.set_trace()
pre_time_in_frames = int(np.ceil(pre_time_in_sec /
TIME_BETWEEN_FRAMES))
post_time_in_frames = int(
np.ceil(post_time_in_sec / TIME_BETWEEN_FRAMES))
for key in ['on', 'off']:
if key is 'on':
col = 'k'
else:
col = 'r'
crax = ax[key][crind]
st_time = stim_time_in_sec[key][crind]
st_frame = int(np.ceil(st_time / TIME_BETWEEN_FRAMES) - 1)
modvl = np.mod(st_time / TIME_BETWEEN_FRAMES,
np.floor(st_time / TIME_BETWEEN_FRAMES))
crax.plot(np.arange(pre_time_in_frames),
dt['mn_roi'][roi_ind][st_frame -
pre_time_in_frames:st_frame],
color=col,
linewidth=0.5)
stim_duration_in_frames = stim_duration / TIME_BETWEEN_FRAMES
st_time_in_frames = pre_time_in_frames - 1 + modvl
crax.plot([
st_time_in_frames, st_time_in_frames + stim_duration_in_frames
], [700, 700],
color='c',
linewidth=2)
pre_f = dt['deltaf_vls']['pre_f'][roi_ind][stim_ind[key]]
pst_f = dt['deltaf_vls']['pst_f'][roi_ind][stim_ind[key]]
crax.plot(39, pre_f, '<')
crax.plot(50, pst_f, '<')
crax.plot(np.arange(post_time_in_frames) + pre_time_in_frames + 3,
dt['mn_roi'][roi_ind][st_frame + 3:st_frame + 3 +
post_time_in_frames],
color=col,
linewidth=0.5)
fpl.adjust_spines(crax, ['left'])
crax.set_ylim(300, 900)
crax.set_yticks([300, 900])
if crind == 0:
if key is 'on':
crax.plot([10, 10 + 1 / TIME_BETWEEN_FRAMES], [350, 350],
'k')
def check_if_period_calculated(fname):
#check if file exists
pck_fname = fname.strip('.txt') + '_sumdata.pck'
if os.path.isfile(pck_fname):
params = fh.open_pickle(pck_fname)
try:
return params['steps_per_rotation'], params['corr_dict']
except:
return
else:
return
def get_data_by_fly(self):
#print
EXPCT=0
self.suffix=self.crflyname+'/cloop/'
files = sorted(os.listdir(self.datapath+self.suffix))
crdt={}
pck_files = [f for f in files if f.find(self.cr_indata_str)>0]
for self.crfile in pck_files:
crdata=fh.open_pickle(self.datapath+self.suffix+self.crfile)
if crdata:
crdt[EXPCT]=crdata
if ADD_START_ANGLE:
skip_flag=False
if 'exp' in crdata['sumstats'].keys():
crkey='exp'
elif 'ctrl' in crdata['sumstats'].keys():
crkey='ctrl'
else:
skip_flag=True
if not skip_flag:
cr_rad=crdata['sumstats'][crkey]['mot_rad']
mnvl=circ.circmean(cr_rad[0:2])
crdt[EXPCT]['sumstats'][crkey]['start_rad']=circ.circmean(mnvl)
if mnvl>100:
print('mnvl greater than 100')
if ADD_TIME_OF_DAY:
if 'exp' in crdata['sumstats'].keys():
crkey='exp'
elif 'ctrl' in crdata['sumstats'].keys():
crkey='ctrl'
else:
skip_flag=True
if not skip_flag:
tst=1
EXPCT=EXPCT+1
if crdt:
crdt=self.add_total_vec_strength_across_paired(crdt)
self.sumdt[self.flyct]=crdt
self.sumdt[self.flyct]['crday']=self.crday
self.flyct=self.flyct+1
def get_fly_data(self, crflynum):
try:
fname_to_plot = self.sumdt[crflynum][0]['sumstats'][0]['fname']
except:
self.crdt = {}
return
split_name = fname_to_plot.split('Dropbox')
datpath = dropbox_path + 'Dropbox' + split_name[1].strip(
'.txt') + '_rawdata.pck'
self.crdt = fh.open_pickle(datpath)
print 'pickle file opened'
def get_data_by_file(self):
mod_file_name = os.path.join(self.in_data_path,
'modified_raw_data.pck')
self.fname = os.path.join(self.in_data_path, self.crfile)
pck_fname = self.fname.strip('.txt') + '.pck'
try:
self.params = fh.open_pickle(pck_fname)
except:
print('open pickle error')
try:
if not os.path.isfile(mod_file_name):
self.tmpdat = (np.array(np.genfromtxt(self.fname)))
else:
self.tmpdat = fh.open_pickle(mod_file_name)
except:
print('file name error')
self.tmpdat = []
self.prep_data_fxn()
if self.crdata:
#if self.exp_type=='closed':
self.anal_closed_stroke_data()
if self.anal_type == 'paired':
self.datvls[self.pairind] = {}
self.datvls[self.pairind]['sumstats'] = self.sumstats
self.datvls[self.pairind]['splitstats'] = self.splitstats
else:
self.datvls['PAIR_FLAG'] = 0
self.datvls['sumstats'] = self.sumstats
self.datvls['splitstats'] = self.splitstats
self.datvls['params'] = self.params
def get_data(self,crfly):
crexp=0
crind=0
try:
split_name=self.sumdt[crfly][crexp]['sumstats'][crind]['fname'].split('Dropbox/')
DAT_FLAG=True
except:
DAT_FLAG=False
if DAT_FLAG:
if len(split_name)<2:
split_name=self.sumdt[crfly][crexp]['sumstats']['sun'][0]['fname'].split('data/')
datpath=dropbox_path+split_name[1].strip('.txt')+'_rawdata.pck'
params_datapath=dropbox_path+split_name[1].strip('.txt')+'.pck'
try:
self.crdt=fh.open_pickle(datpath)
self.params=fh.open_pickle(params_datapath)
except:
pdb.set_trace()
else:
self.crdt=[]
#file_name=['2x 10 micron diam z-stack20space seperation - 1_XY1553116792_Z000_T0_C0.tif']
microns_per_pixel = 1.47441
off_target_centers = [[182, 195], [190, 189]]
on_target_centers = [[179, 186], [187.5, 202]]
UNIQUE_STIM_EVENTS = 1
fig = plt.figure()
ax = []
ax.append(fig.add_subplot(221))
ax.append(fig.add_subplot(222))
ax.append(fig.add_subplot(223))
ax.append(fig.add_subplot(224))
stim_region = {}
for crind in np.arange(len(file_names)):
dt = util.read_in_tif(data_path + file_names[crind])
savedt = fh.open_pickle(data_path + pck_name)
stim_region = savedt['stim_region']
pdb.set_trace()
plt.set_cmap('hot')
imobj = ax[crind].imshow(dt['tifstack'])
ax[crind].set_xlim(140, 240)
ax[crind].set_ylim(125, 240)
if crind == 0:
imobj.set_clim(200, 500)
if crind == 1:
imobj.set_clim(200, 500)
imobj = ax[crind + 2].imshow(dt['tifstack'])
imobj.set_clim(100, 900)
ax[crind + 2].set_xlim(130, 250)
ax[crind + 2].set_ylim(130, 250)
TIME_BETWEEN_FRAMES = .12625
PREVIOUS_ROI_FILE = '---Streaming Phasor Capture - 8_XY0_Z0_T0000_C0.tif'
#specific to configuration
data_path = '/Volumes/LaCie/tstdir/'
meta_dt_file = 'anim5_plotdata.pck'
stim_meta_dir = 'photomanipulation_data/'
#file_names= ['---Streaming Phasor Capture - 1_XY0_Z0_T000_C0.tif']
file_names = ['---Streaming Phasor Capture - 8_XY0_Z0_T0000_C0.tif']
preframes = 20
postframes = 5
stim_region = {}
colors = ['c', 'g', 'm', 'b']
#read in tif file
if USE_META_DT_FILE:
meta_dt = fh.open_pickle(data_path + meta_dt_file)
file_names = meta_dt['file_names']
PREVIOUS_ROI_FILE = file_names[0]
#im is a dictionary with tifstack and metadata about imaging from PMT
for file_name in file_names:
(im, stim) = util.read_in_tif_and_get_metadata(data_path + file_name)
if STIM_FLAG:
logfile = file_name.split('_')[0] + '.txt'
stimfile = data_path + stim_meta_dir + logfile
(stim_depths, erroneous_stim_times) = util.get_stim_depths(stimfile)
roi_file = stimfile.split('.txt')[0] + '-points.txt'
(stim_region['xlist'], stim_region['ylist']) = util.get_stim_region(
roi_file, unique_events=UNIQUE_STIM_EVENTS)
def main():
mn_by_animal = {}
for file_ind, crfile in enumerate(summary_data_files_to_load):
dt = fh.open_pickle(summary_data_location + crfile)
delta_f = dt['delta_f']
fvls_array = {}
for target_key in ['on', 'off']:
if file_ind == 0:
mn_by_animal[target_key] = []
fvls_sum = {}
fvls_sum['raw'] = []
fvls_sum['norm'] = []
fvls_array[target_key] = {}
for expind, exp_key in enumerate(delta_f.keys()):
try:
fvls_to_add = delta_f[exp_key][target_key]['fvl']
except:
fvls_to_add = delta_f[exp_key][target_key]['fvl_raw']
norm_fvls_to_add = fvls_to_add / dt['max_value'][exp_key]
fvls_sum['norm'].append(norm_fvls_to_add)
if expind > 0:
crlen = len(fvls_sum['raw'][0])
if len(fvls_to_add) > crlen:
pdb.set_trace()
fvls_to_add = fvls_to_add[0:crlen]
fvls_sum['raw'].append(fvls_to_add)
shape1 = np.shape(fvls_sum['norm'])[0]
if len(np.shape(fvls_sum['norm'])) == 2:
shape = np.shape(fvls_sum['norm'])
fvls_array[target_key]['fvl_norm'] = np.mean(np.array(
fvls_sum['norm']),
axis=0)
try:
fvls_array[target_key]['fvl_raw'] = np.mean(np.array(
fvls_sum['raw']),
axis=0)
except:
pdb.set_trace()
tmp_depth = delta_f[0][target_key]['depth']
if ROUND_TO_NEAREST:
fvls_array[target_key]['depth'] = myround(
np.array(tmp_depth), base=ROUND_TO_NEAREST)
else:
fvls_array[target_key]['depth'] = np.array(tmp_depth)
mn_by_animal[target_key].append(
calc_mean_for_animal_over_depth_range(fvls_array[target_key],
target_key))
norm_flag = False
plt_util.plot_raw(axnorm, fvls_array, norm_flag, line_flag=True)
fpl.adjust_spines(axnorm, ['left', 'bottom'])
axnorm.set_ylim(-.25, 0.75)
axnorm.set_yticks([-.25, 0, 0.25, 0.5, 0.75])
axnorm.set_xlim(-62, 42)
plot_sum_for_each_animal(axsum, mn_by_animal)
