def After_Align_Average(self):
"""
This Functin will generate after align average graph of Run and Global, and then save them.
Returns
-------
None.
"""
print('Aligning done. ')
self.After_Align_Graphs = {} # Initialize a dictionary, will record all aligned graphs averages and graph nums.
# Fill After Align Graph Dictionary first
total_graph_num = 0
for i in range(len(self.Aligned_frame_folders)):
current_run_names = OS_Tools.Get_File_Name(self.Aligned_frame_folders[i])
temp_average = Graph_Tools.Average_From_File(current_run_names) # This will generate an average graph with 'f8' formation.
current_graph_aligned = Graph_Tools.Clip_And_Normalize(temp_average,clip_std = 5)
Graph_Tools.Show_Graph(current_graph_aligned, 'Run_Average_After_Align', self.all_save_folders[i])
current_run_Frame_Num = len(current_run_names)
total_graph_num += current_run_Frame_Num
self.After_Align_Graphs[i] = (current_graph_aligned,current_run_Frame_Num)
global_average_after_align = np.zeros(np.shape(current_graph_aligned),dtype = 'f8')
# Then calculate global average in each run.
for i in range(len(self.all_save_folders)):
global_average_after_align += self.After_Align_Graphs[i][0].astype('f8')*self.After_Align_Graphs[i][1]/total_graph_num
global_average_after_align = Graph_Tools.Clip_And_Normalize(global_average_after_align,clip_std = 5)
# Then save global graph into each folder.
for i in range(len(self.all_save_folders)):
if i == 0:
Graph_Tools.Show_Graph(global_average_after_align, 'Global_Average_After_Align', self.all_save_folders[i])
else:
Graph_Tools.Show_Graph(global_average_after_align, 'Global_Average_After_Align', self.all_save_folders[i],show_time = 0)
def One_Key_Frame_Graphs(
data_folder,
sub_dic,
show_clip=3,
alinged_sub_folder=r'\Results\Final_Aligned_Frames',
Stim_Align_sub_folder=r'\Results\Stim_Frame_Align.pkl'):
result_folder = data_folder + r'\Results'
graph_save_folder = result_folder + r'\Only_Frame_SubGraphs'
OS_Tools.mkdir(result_folder)
OS_Tools.mkdir(graph_save_folder)
stim_path = data_folder + Stim_Align_sub_folder
stim_dic = OS_Tools.Load_Variable(stim_path)
all_tif_name = OS_Tools.Get_File_Name(data_folder + alinged_sub_folder)
graph_num = len(sub_dic)
all_sub_graph_names = list(sub_dic.keys())
for i in range(graph_num):
current_name = all_sub_graph_names[i]
current_a = Frame_ID_Extractor(stim_dic, sub_dic[current_name][0])
current_b = Frame_ID_Extractor(stim_dic, sub_dic[current_name][1])
current_sub_graph, current_t_graph, current_info_dic = Single_Subgraph_Generator(
all_tif_name, current_a, current_b)
current_sub_graph = Graph_Tools.Clip_And_Normalize(
current_sub_graph, show_clip)
current_t_graph = Graph_Tools.Clip_And_Normalize(
current_t_graph, show_clip)
# Save graphs
Graph_Tools.Show_Graph(current_sub_graph, current_name + '_Sub_Graph',
graph_save_folder)
Graph_Tools.Show_Graph(current_t_graph, current_name + '_t_Graph',
graph_save_folder)
OS_Tools.Save_Variable(graph_save_folder, current_name + r'_Sub_Info',
current_info_dic, '.info')
return True
def Before_Run_Average(self):
"""
Generate global and per run average graph.
This part is automatic,output averaged graph in folder, return nothing.
Returns
-------
None.
"""
print('Averaging before align...')
#Get Run Average First
self.Before_Align_Dics = {}# Define a dictionary to save before align graphs.
total_graph_num = 0 # counter of graph numbers
for i in range(len(self.Before_Align_Tif_Name)):
run_graph_num = len(self.Before_Align_Tif_Name[i])# How many graphs in this run
total_graph_num += run_graph_num
current_run_average = Graph_Tools.Average_From_File(self.Before_Align_Tif_Name[i])
current_run_average = Graph_Tools.Clip_And_Normalize(current_run_average,clip_std = 5)
self.Before_Align_Dics[i] = (current_run_average,run_graph_num) # Write Current dict as a Tuple.
Graph_Tools.Show_Graph(current_run_average, 'Run_Average',self.all_save_folders[i])# Show and save Run Average.
# Then Use Weighted average method to generate global tif. This methos can be faster than original ones.
global_average_graph = np.zeros(shape = np.shape(self.Before_Align_Dics[0][0]),dtype = 'f8')# Base on shape of graph
for i in range(len(self.Before_Align_Tif_Name)):
global_average_graph += self.Before_Align_Dics[i][0].astype('f8')*self.Before_Align_Dics[i][1]/total_graph_num
global_average_graph = Graph_Tools.Clip_And_Normalize(global_average_graph,clip_std = 5)
# At last, save global average graph in every run folders.
for i in range(len(self.all_save_folders)):
Graph_Tools.Show_Graph(global_average_graph, 'Global_Average', self.all_save_folders[i],show_time = 0)
self.Align_Base = global_average_graph # Define Base of Alignment, use this to do the job.
def On_Off_Cell_Finder(
all_tif_name,
Stim_Frame_Dic,
find_thres = 1.5,
max_pix = 1000,
min_pix = 20,
filter_method = 'Gaussian',
LP_Para = ((5,5),1.5),
HP_Para = False,
shape_boulder = [20,20,20,20],
sharp_gauss = ([7,7],1.5),
back_gauss = ([15,15],7),
size_limit = 20
):
# Generater On-Off graph.
off_list = Stim_Frame_Dic[0]
all_keys = list(Stim_Frame_Dic.keys())
all_keys.remove('Original_Stim_Train')
all_keys.remove(-1)
all_keys.remove(0)
on_list = []
for i in range(len(all_keys)):
on_list.extend(Stim_Frame_Dic[all_keys[i]])
on_off_graph,_,_ = Single_Subgraph_Generator(all_tif_name, on_list, off_list,filter_method,LP_Para,HP_Para,t_map = False)
on_off_graph = Graph_Tools.Clip_And_Normalize(on_off_graph,clip_std = 2.5)
Finded_Cells = Cell_Find_From_Graph(on_off_graph,find_thres,max_pix,min_pix,shape_boulder,sharp_gauss,back_gauss,size_limit)
return on_off_graph,Finded_Cells
def Cell_Find_From_active(
aligned_data_folder,
find_thres = 1,
active_mode = 'biggest',
propotion = 0.05,
max_pix = 1000,
min_pix = 20,
shape_boulder = [20,20,20,20],
sharp_gauss = ([7,7],1.5),
back_gauss = ([15,15],7),
size_limit = 20
):
intensity_selected_graph,_ = Graph_Selector.Intensity_Selector(aligned_data_folder,mode = active_mode,propotion=propotion,list_write=False)
save_folder = '\\'.join(aligned_data_folder.split('\\')[:-1])
Graph_Tools.Show_Graph(Graph_Tools.Clip_And_Normalize(intensity_selected_graph,clip_std = 5), 'Cell_Find_Base', save_folder)
Cell_Finded = Cell_Find_And_Plot(save_folder, 'Cell_Find_Base.tif', 'Active_Cell',find_thres,max_pix,min_pix,shape_boulder,sharp_gauss,back_gauss,size_limit)
return Cell_Finded
def Translation_Alignment(all_folders,
base_mode='global',
input_base=np.array([[0, 0], [0, 0]]),
align_range=20,
align_boulder=20,
before_average=True,
average_std=5,
big_memory_mode=False,
save_aligned_data=False,
graph_shape=(512, 512),
timer=True):
'''
This function will align all tif graphs in input folders. Only translation transaction here. Affine transformation need further discussion.
Parameters
----------
all_folders:(list)
List of all tif folders, elements are strs.
base_mode:('global',int,'input',optional. The default is 'global')
How to select base frame. 'global': use global average as base. int: use average of specific run as base. 'input':Manually input base graph, need to be a 2D-Ndarray.
input_base:(2D-Ndarray,optional. The default is none.)
If base_mode = 'input', input_base must be given. This will be the base for alignment.
align_range:(int,optional. The default is 20)
Max pixel of alignment.
align_boulder:(int,optional. The default is 20)
boulder cut for align. For different graph size, this variable shall be change.
before_average:(bool,optional. The default is True)
Whether before average is done. It can be set False to save time, on this case base graph shall be given.
average_std:(float,optional. The default is 5)
How much std you want for average graph generation. Different std can effect graph effect.
big_memory_mode:(bool,optional. The default is False)
If memory is big enough, use this mode is faster.
save_aligned_data:(bool,optional. The default is False)
Can be true only in big memory mode. This will save all aligned graph in a single 4D-Ndarray file.Save folder is the first folder.
graph_shape:(2-element-turple,optional. The default is (512,512))
Shape of graphs. All input graph must be in same shape.
timer:(bool,optional. The default is True)
Show runtime of function and each procedures.
Returns
-------
bool
Whether new folder is generated.
'''
time_tic_start = time.time()
#%% Step1, generate folders and file cycle.
all_save_folders = List_Op.List_Annex(all_folders, ['Results'])
Aligned_frame_folders = List_Op.List_Annex(all_save_folders,
['Aligned_Frames'])
for i in range(len(all_save_folders)):
OS_Tools.mkdir(all_save_folders[i])
OS_Tools.mkdir(Aligned_frame_folders[i])
Before_Align_Tif_Name = []
for i in range(len(all_folders)):
current_run_tif = OS_Tools.Get_File_Name(all_folders[i])
Before_Align_Tif_Name.append(current_run_tif)
#%% Step2, Generate average map before align.
if before_average == True:
print('Before run averaging ...')
Before_Align_Dics = {
} # This is the dictionary of all run averages. Keys are run id.
total_graph_num = 0 # Counter of graph numbers.
for i in range(len(Before_Align_Tif_Name)):
current_run_graph_num = len(Before_Align_Tif_Name[i])
total_graph_num += current_run_graph_num
current_run_average = Graph_Tools.Average_From_File(
Before_Align_Tif_Name[i])
current_run_average = Graph_Tools.Clip_And_Normalize(
current_run_average, clip_std=average_std)
Before_Align_Dics[i] = (
current_run_average, current_run_graph_num
) # Attention here, data recorded as turple.
Graph_Tools.Show_Graph(
current_run_average, 'Run_Average',
all_save_folders[i]) # Show and save Run Average.
# Then Use Weighted average method to generate global tif.
global_average_graph = np.zeros(shape=np.shape(
Before_Align_Dics[0][0]),
dtype='f8') # Base on shape of graph
for i in range(len(Before_Align_Tif_Name)):
global_average_graph += Before_Align_Dics[i][0].astype(
'f8') * Before_Align_Dics[i][1] / total_graph_num
global_average_graph = Graph_Tools.Clip_And_Normalize(
global_average_graph, clip_std=average_std)
# Then save global average in each run folder.
if len(all_folders) > 1:
for i in range(len(Before_Align_Tif_Name)):
Graph_Tools.Show_Graph(global_average_graph,
'Global_Average',
all_save_folders[i],
show_time=0)
else:
print('Only One run, no global average.')
else:
print('Before average Skipped.')
time_tic_average0 = time.time()
#%% Step3, Core Align Function.
print('Aligning...')
if base_mode == 'global':
base = global_average_graph
elif base_mode == 'input':
base = input_base
elif type(base_mode) == int:
base = Before_Align_Dics[base_mode][0]
else:
raise IOError('Invalid base mode.')
# In big memory mode, save aligned_data in a dictionary file.
if big_memory_mode == True:
All_Aligned_Frame = {}
for i in range(len(Before_Align_Tif_Name)):
All_Aligned_Frame[i] = np.zeros(
shape=(graph_shape + (len(Before_Align_Tif_Name[i]), )),
dtype='u2') # Generate empty graph matrix.
for i in range(len(Before_Align_Tif_Name)): # Cycle all runs
for j in range(len(
Before_Align_Tif_Name[i])): # Cycle all graphs in current run
current_graph = cv2.imread(Before_Align_Tif_Name[i][j],
-1) # Read in current graph.
_, _, current_aligned_graph = Alignment(base,
current_graph,
boulder=align_boulder,
align_range=align_range)
graph_name = Before_Align_Tif_Name[i][j].split(
'\\')[-1][:-4] # Ignore extend name'.tif'.
Graph_Tools.Show_Graph(current_aligned_graph,
graph_name,
Aligned_frame_folders[i],
show_time=0)
if big_memory_mode == True:
All_Aligned_Frame[i][:, :, j] = current_aligned_graph
print('Align Finished, generating average graphs...')
time_tic_align_finish = time.time()
#%% Step4, After Align Average
After_Align_Graphs = {}
if big_memory_mode == True: # Average can be faster.
temp_global_average_after_align = np.zeros(shape=graph_shape,
dtype='f8')
for i in range(len(All_Aligned_Frame)):
current_run_average = Graph_Tools.Clip_And_Normalize(
np.mean(All_Aligned_Frame[i], axis=2),
clip_std=average_std) # Average run graphs, in type 'u2'
After_Align_Graphs[i] = (current_run_average,
len(All_Aligned_Frame[i][0, 0, :]))
temp_global_average_after_align += After_Align_Graphs[i][0].astype(
'f8') * After_Align_Graphs[i][1] / total_graph_num
global_average_after_align = Graph_Tools.Clip_And_Normalize(
temp_global_average_after_align, clip_std=average_std)
else: # Traditional ways.
temp_global_average_after_align = np.zeros(shape=graph_shape,
dtype='f8')
for i in range(len(Aligned_frame_folders)):
current_run_names = OS_Tools.Get_File_Name(
Aligned_frame_folders[i])
current_run_average = Graph_Tools.Average_From_File(
current_run_names)
current_run_average = Graph_Tools.Clip_And_Normalize(
current_run_average, clip_std=average_std)
After_Align_Graphs[i] = (current_run_average,
len(current_run_names))
temp_global_average_after_align += After_Align_Graphs[i][0].astype(
'f8') * After_Align_Graphs[i][1] / total_graph_num
global_average_after_align = Graph_Tools.Clip_And_Normalize(
temp_global_average_after_align, clip_std=average_std)
# After average, save aligned graph in each save folder.
for i in range(len(all_save_folders)):
current_save_folder = all_save_folders[i]
Graph_Tools.Show_Graph(After_Align_Graphs[i][0],
'Run_Average_After_Align', current_save_folder)
if i == 0: # Show global average only once.
global_show_time = 5000
else:
global_show_time = 0
if len(all_folders) > 1:
Graph_Tools.Show_Graph(global_average_after_align,
'Global_Average_After_Align',
current_save_folder,
show_time=global_show_time)
time_tic_average1 = time.time()
#%% Step5, save and timer
if save_aligned_data == True:
OS_Tools.Save_Variable(all_save_folders[0], 'All_Aligned_Frame_Data',
All_Aligned_Frame)
if timer == True:
whole_time = time_tic_average1 - time_tic_start
before_average_time = time_tic_average0 - time_tic_start
align_time = time_tic_align_finish - time_tic_average0
after_average_time = time_tic_average1 - time_tic_align_finish
print('Total Time = ' + str(whole_time) + ' s.')
print('Before Average Time = ' + str(before_average_time) + ' s.')
print('Align Time = ' + str(align_time) + ' s.')
print('After Average Time = ' + str(after_average_time) + ' s.')
return True
base_graph = cv2.imread(
r'K:\Test_Data\2P\210320_L76_2P\1-001\Results\Global_Average_After_Align.tif',
-1)
Translation_Alignment(all_run_folder[2:],
base_mode='input',
input_base=base_graph,
align_range=35)
# Find some small mismatch, try affine methods.
affine_base = cv2.imread(
r'K:\Test_Data\2P\210320_L76_2P\_Affine_Affairs\Affine_Base.tif', -1)
Affine_Aligner_Gaussian(all_run_folder[0], affine_base, write_file=False)
for i in range(2, 15):
Affine_Aligner_Gaussian(all_run_folder[i], affine_base, write_file=False)
# Get all aligned_average
all_avr = gt.Global_Averagor(all_run_folder)
gt.Show_Graph(gt.Clip_And_Normalize(all_avr, 5), 'Global_Average_After_Affine',
r'K:\Test_Data\2P\210320_L76_2P\_Affine_Affairs')
# Then align all stim runs
from My_Wheels.Stim_Frame_Align import One_Key_Stim_Align
One_Key_Stim_Align(r'K:\Test_Data\2P\210320_L76_2P\210320_L76_2P_stimuli')
# calculate frame submaps.
from Standard_Parameters.Sub_Graph_Dics import Sub_Dic_Generator
from Standard_Stim_Processor import One_Key_Frame_Graphs
G16_Para = Sub_Dic_Generator('G16_2P')
One_Key_Frame_Graphs(r'K:\Test_Data\2P\210320_L76_2P\1-005',
G16_Para,
alinged_sub_folder=r'\Results\Affined_Frames')
OD_Para = Sub_Dic_Generator('OD_2P')
One_Key_Frame_Graphs(r'K:\Test_Data\2P\210320_L76_2P\1-010',
OD_Para,
alinged_sub_folder=r'\Results\Affined_Frames')
def Graph_Cutter(
input_graph,
boulder=20,
cut_shape=(4, 4),
):
"""
Cut a whole graph into small pieces.
Parameters
----------
input_graph : (2D_NdArray)
Input graph of calculation.
boulder : (int), optional
Boulder cut to get rid of move error. The default is 20.
cut_shape : (turple), optional
Shape you want to cut graph into. The default is (4,4).
Returns
-------
schametic : (2D-NdArray,dtype = 'u1')
Schamatic graph of cut method, with ID on graph.
graph_lacation_dics : (list)
List of left upper coordinate of each graph.
after_size : (turple)
Size of small graph after cut. 2-element turple, yx.
cutted_graph_dics : (Dic)
Dictionary of cutted graphs.
"""
length, width = np.shape(input_graph)
length_after_cut = length - boulder * 2
width_after_cut = width - boulder * 2
# Get shape of cutted graph
cutted_length = length_after_cut // cut_shape[0]
cutted_width = width_after_cut // cut_shape[1]
after_size = (cutted_length, cutted_width)
graph_location_list = []
# cycle all fractions.
cutted_graph_dics = {}
current_fraction_id = 0
for i in range(cut_shape[1]):
for j in range(cut_shape[0]):
left_up_point = (boulder + j * cutted_length,
boulder + i * cutted_width)
graph_location_list.append(left_up_point)
current_image = input_graph[left_up_point[0]:left_up_point[0] +
cutted_length,
left_up_point[1]:left_up_point[1] +
cutted_width]
cutted_graph_dics[current_fraction_id] = current_image
current_fraction_id += 1
# Then draw schametic graph, and show id on it. cv2 location id sequence is xy!!
schametic = Graph_Tools.Clip_And_Normalize(input_graph,
clip_std=10,
bit='u1')
for i in range(cut_shape[0] + 1): # Draw horizontal lines
cv2.line(schametic, (boulder, boulder + i * cutted_length),
(width - boulder, boulder + i * cutted_length), (255), 2)
for i in range(cut_shape[1] + 1): #...And vertical lines
cv2.line(schametic, (boulder + i * cutted_width, boulder),
(boulder + i * cutted_width, length - boulder), (255), 2)
for i in range(len(graph_location_list)): # And put graph id on them.
text_loc = (graph_location_list[i][1] + cutted_width // 2,
graph_location_list[i][0] + cutted_length // 2)
cv2.putText(schametic, str(i), text_loc,
cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (255), 1)
return schametic, graph_location_list, after_size, cutted_graph_dics
"""
Created on Tue Oct 27 13:41:07 2020
@author: ZR
Codes to process L76 Data
"""
import My_Wheels.Graph_Operation_Kit as Graph_Tools
import My_Wheels.OS_Tools_Kit as OS_Tools
#%% Cell1, Average Graph.
graph_folder = r'I:\Test_Data\201023_L76_LM\1-003'
save_path = graph_folder + r'\Results'
OS_Tools.mkdir(save_path)
all_tif_name = OS_Tools.Get_File_Name(graph_folder)
average_graph = Graph_Tools.Average_From_File(all_tif_name)
norm_average_graph = Graph_Tools.Clip_And_Normalize(average_graph, clip_std=3)
Graph_Tools.Show_Graph(norm_average_graph, 'Average_Graph', save_path)
#%% Then Calculate Runs
graph_folder = r'I:\Test_Data\201023_L76_LM\1-013'
import My_Wheels.Translation_Align_Function as Align
Align.Translation_Alignment([graph_folder])
#%% Align Stim and Frame
import My_Wheels.Stim_Frame_Align as Stim_Frame_Align
stim_folder = r'I:\Test_Data\201023_L76_LM\201023_L76_LM_Stimulus\Run13_RGLum4'
Frame_Stim_Sequence, Frame_Stim_Dictionary = Stim_Frame_Align.Stim_Frame_Align(
stim_folder)
aligned_tif_name = OS_Tools.Get_File_Name(
r'I:\Test_Data\201023_L76_LM\1-013\Results\Aligned_Frames')
#%% Generate On-Off Map
on_id = []
on_id.extend(Frame_Stim_Dictionary[3])
def Standard_Stim_Processor(data_folder,
stim_folder,
sub_dic,
alinged_sub_folder=r'\Results\Aligned_Frames',
show_clip=3,
tuning_graph=False,
cell_method='Default',
filter_method='Gaussian',
LP_Para=((5, 5), 1.5),
HP_Para=False,
spike_train_path='Default',
spike_train_filter_para=(False, False),
spike_train_filter_method=False):
'''
Generate subtraction graph, cell graph and tuning graphs if requred.
Parameters
----------
data_folder : (str)
Run folder.
stim_folder : (str)
Stim file folder or Frame_Stim_Align File folder. Pre align is advised.
sub_dic : (Dic)
Subtraction dicionary. This can be generated from My_Wheels.Standard_Parameters
show_clip : (float), optional
Clip of graph show. The default is 3.
tuning_graph : (bool), optional
Whether we generate tuning graph of each cells. The default is False.
cell_method : (str), optional
Cell find method. You can input cell file path here. The default is 'Default'.
filter_method : (str), optional
False to skip filter. Kernel function of graph filtering. The default is 'Gaussian'.
LP_Para : (turple), optional
False to skip. Low pass filter of graph. The default is ((5,5),1.5).
HP_Para : (turple), optional
False to skip. High pass filter of graph. Big HP can be very slow!. The default is False.
spike_train_path : (str), optional
Path of spike train.'Default' will generate spike train directly. The default is 'Default'.
spike_train_filter_para : (turple), optional
Signal filter bandpass propotion of spike train. Please be sure if you need this. The default is (False,False).
spike_train_filter_method : (str), optional
False to skip. Method of signal filtering. The default is False.
Returns
-------
None.
'''
# Path Cycle.
from Cell_Find_From_Graph import On_Off_Cell_Finder
work_folder = data_folder + r'\Results'
OS_Tools.mkdir(work_folder)
aligned_frame_folder = data_folder + alinged_sub_folder
OS_Tools.mkdir(aligned_frame_folder)
# Step1, align graphs. If already aligned, just read
if not os.listdir(aligned_frame_folder): # if this is a new folder
print('Aligned data not found. Aligning here..')
Translation_Alignment([data_folder])
aligned_all_tif_name = np.array(
OS_Tools.Get_File_Name(aligned_frame_folder)
) # Use numpy array, this is easier for slice.
# Step2, get stim fram align matrix. If already aligned, just read in aligned dictionary.
file_detector = len(stim_folder.split('.'))
if file_detector == 1: # Which means input is a folder
print('Frame Stim not Aligned, aligning here...')
from My_Wheels.Stim_Frame_Align import Stim_Frame_Align
_, Frame_Stim_Dic = Stim_Frame_Align(stim_folder)
else: # Input is a file
Frame_Stim_Dic = OS_Tools.Load_Variable(stim_folder)
# Step3, get cell information
if cell_method == 'Default': # meaning we will use On-Off graph to find cell.
print('Cell information not found. Finding here..')
cell_dic = On_Off_Cell_Finder(aligned_all_tif_name,
Frame_Stim_Dic,
filter_method=filter_method,
LP_Para=LP_Para,
HP_Para=HP_Para)
else:
cell_dic = OS_Tools.Load_Variable(cell_method)
# Step4, calculate spike_train.
if spike_train_path != 'Default':
dF_F_train = OS_Tools.Load_Variable(spike_train_path)
else: # meaning we need to calculate spike train from the very begining.
_, dF_F_train = Spike_Train_Generator(
aligned_all_tif_name,
cell_dic['All_Cell_Information'],
Base_F_type='nearest_0',
stim_train=Frame_Stim_Dic['Original_Stim_Train'],
LP_Para=LP_Para,
HP_Para=HP_Para,
filter_method=filter_method)
#Step5, filt spike trains.
if spike_train_filter_method != False: # Meaning we need to do train filter.
for i in range(len(dF_F_train)):
dF_F_train[i] = My_Filter.Signal_Filter(dF_F_train,
spike_train_filter_method,
spike_train_filter_para)
# Step6, get each frame graph and cell graph.
all_graph_keys = list(sub_dic.keys())
for i in range(len(sub_dic)):
output_folder = work_folder + r'\Subtraction_Graphs'
current_key = all_graph_keys[i]
current_sub_list = sub_dic[current_key]
A_conds = current_sub_list[0] # condition of A graph
B_conds = current_sub_list[1] # condition of B graph
A_IDs = []
B_IDs = []
for i in range(len(A_conds)):
A_IDs.extend(Frame_Stim_Dic[A_conds[i]])
for i in range(len(B_conds)):
B_IDs.extend(Frame_Stim_Dic[B_conds[i]])
# Get frame maps.
current_sub_graph, current_t_graph, current_F_info = Single_Subgraph_Generator(
aligned_all_tif_name, A_IDs, B_IDs, filter_method, LP_Para,
HP_Para)
current_sub_graph = Graph_Tools.Clip_And_Normalize(
current_sub_graph, show_clip)
Graph_Tools.Show_Graph(current_sub_graph, current_key + '_SubGraph',
output_folder)
current_t_graph = Graph_Tools.Clip_And_Normalize(
current_t_graph, show_clip)
Graph_Tools.Show_Graph(current_t_graph, current_key + '_T_Graph',
output_folder)
OS_Tools.Save_Variable(output_folder,
current_key + '_Sub_Info',
current_F_info,
extend_name='.info')
# Get cell maps
cell_info = cell_dic['All_Cell_Information']
current_cell_sub_graph, current_cell_t_graph, current_cell_info = Single_Cellgraph_Generator(
dF_F_train, cell_info, show_clip, A_IDs, B_IDs)
Graph_Tools.Show_Graph(current_cell_sub_graph,
current_key + '_Cell_SubGraph', output_folder)
Graph_Tools.Show_Graph(current_cell_t_graph,
current_key + '_Cell_T_Graph', output_folder)
OS_Tools.Save_Variable(output_folder,
current_key + '_Cell_Info',
current_cell_info,
extend_name='.info')
#Step7, calculate cell tuning graph.
if tuning_graph == True:
print('Not finished yet.')
def Affine_Aligner_Gaussian(data_folder,
base_graph,
window_size=1,
max_point=50000,
good_match_prop=0.3,
dist_lim=120,
match_checker=1,
sector_num=4,
write_file=False,
save_folder='Default'):
if save_folder == 'Default':
save_folder = data_folder + r'\Results'
aligned_tif_folder = save_folder + r'\Affined_Frames'
OS_Tools.mkdir(save_folder)
OS_Tools.mkdir(aligned_tif_folder)
all_tif_name = OS_Tools.Get_File_Name(data_folder)
graph_num = len(all_tif_name)
graph_shape = cv2.imread(all_tif_name[0], -1).shape
height, width = graph_shape
origin_tif_matrix = np.zeros(shape=graph_shape + (graph_num, ), dtype='u2')
# Read in all tif name.
for i in range(graph_num):
origin_tif_matrix[:, :, i] = cv2.imread(all_tif_name[i], -1)
# Then get window slipped average graph.
if window_size == 1:
slipped_average_matrix = origin_tif_matrix
else:
slipped_average_matrix = Filters.Window_Average(
origin_tif_matrix, window_size=window_size)
# Use slip average to get deformation parameters.
aligned_tif_matrix = np.zeros(shape=origin_tif_matrix.shape, dtype='u2')
h_dic = {} # Deformation parameters
for i in range(graph_num):
target = slipped_average_matrix[:, :, i]
_, current_h = Affine_Core_Point_Equal(target,
base_graph,
max_point=max_point,
good_match_prop=good_match_prop,
sector_num=sector_num,
dist_lim=dist_lim,
match_checker=match_checker)
h_dic[i] = current_h
current_deformed_graph = cv2.warpPerspective(
origin_tif_matrix[:, :, i], current_h, (width, height))
Graph_Tools.Show_Graph(current_deformed_graph,
all_tif_name[i].split('\\')[-1],
aligned_tif_folder,
show_time=0,
graph_formation='')
aligned_tif_matrix[:, :, i] = current_deformed_graph
OS_Tools.Save_Variable(save_folder, 'Deform_H', h_dic)
if write_file == True:
OS_Tools.Save_Variable(save_folder, 'Affine_Aligned_Graphs',
aligned_tif_matrix)
# At last, generate average graphs
graph_before_align = origin_tif_matrix.mean(axis=2).astype('u2')
graph_after_align = aligned_tif_matrix.mean(axis=2).astype('u2')
graph_before_align = Graph_Tools.Clip_And_Normalize(graph_before_align,
clip_std=5)
graph_after_align = Graph_Tools.Clip_And_Normalize(graph_after_align,
clip_std=5)
Graph_Tools.Show_Graph(graph_before_align, 'Graph_Before_Affine',
save_folder)
Graph_Tools.Show_Graph(graph_after_align, 'Graph_After_Affine',
save_folder)
return True