update

app.py

@@ -331,7 +331,7 @@ with gr.Blocks() as demo:
 	    	"batchNum" : None,
 	    	"mappingResult" : [
 	    	{
-				"newOrder" : None,
+				"indices" : None,
 				"isOriginalData" : None
 				#"channelUsageNum" : None
 			}
@@ -488,7 +488,7 @@ with gr.Blocks() as demo:
 				prev_tpl_idx = channel_info["templateDict"][prev_tpl_name]["index"]
 				sel_idx = channel_info["inputDict"][sel_radio]["index"]
 				
-				stage1_info["mappingResult"][0]["newOrder"][prev_tpl_idx] = [sel_idx]
+				stage1_info["mappingResult"][0]["indices"][prev_tpl_idx] = [sel_idx]
 				stage1_info["mappingResult"][0]["isOriginalData"][prev_tpl_idx] = True
 				channel_info["templateDict"][prev_tpl_name]["matched"] = True
 				channel_info["inputDict"][sel_radio]["assigned"] = True
@@ -565,10 +565,10 @@ with gr.Blocks() as demo:
 				value of the data from the selected channels. (By default, the 4 nearest channels are pre-selected.)
 				"""
 				# find the 4 nearest in_channels for each unmatched tpl_channels
-				stage1_info["mappingResult"][0]["newOrder"] = app_utils.find_neighbors(
+				stage1_info["mappingResult"][0]["indices"] = app_utils.find_neighbors(
 																		channel_info,
 																		stage1_info["emptyTemplates"],
-																		stage1_info["mappingResult"][0]["newOrder"])
+																		stage1_info["mappingResult"][0]["indices"])
 				# initialize the progress indication label
 				stage1_info["step3"] = {
 					"count" : 1,
@@ -578,7 +578,7 @@ with gr.Blocks() as demo:
 				label = '{} (1/{})'.format(tpl_name, stage1_info["step3"]["totalNum"])
 				
 				tpl_idx = channel_info["templateDict"][tpl_name]["index"]
-				value = stage1_info["mappingResult"][0]["newOrder"][tpl_idx]
+				value = stage1_info["mappingResult"][0]["indices"][tpl_idx]
 				value = [channel_info["inputNames"][i] for i in value]
 				
 				stage1_info["state"] = "step3-2-selecting"
@@ -607,7 +607,7 @@ with gr.Blocks() as demo:
 			prev_tpl_name = stage1_info["emptyTemplates"][stage1_info["step3"]["count"]-1]
 			prev_tpl_idx = channel_info["templateDict"][prev_tpl_name]["index"]
 			sel_idx = [channel_info["inputDict"][name]["index"] for name in sel_chkbox]
-			stage1_info["mappingResult"][0]["newOrder"][prev_tpl_idx] = sel_idx if sel_idx!=[] else [None]
+			stage1_info["mappingResult"][0]["indices"][prev_tpl_idx] = sel_idx if sel_idx!=[] else [None]
 			#print(prev_tpl_name, '<-', sel_chkbox)
 			# ----------------------------------------------------------------------------------
 			md = """
@@ -686,7 +686,7 @@ with gr.Blocks() as demo:
 			prev_tpl_idx = channel_info["templateDict"][prev_tpl_name]["index"]
 			sel_idx = channel_info["inputDict"][sel_name]["index"]
 			
-			stage1_info["mappingResult"][0]["newOrder"][prev_tpl_idx] = [sel_idx]
+			stage1_info["mappingResult"][0]["indices"][prev_tpl_idx] = [sel_idx]
 			stage1_info["mappingResult"][0]["isOriginalData"][prev_tpl_idx] = True
 			channel_info["templateDict"][prev_tpl_name]["matched"] = True
 			channel_info["inputDict"][sel_name]["assigned"] = True
@@ -736,7 +736,7 @@ with gr.Blocks() as demo:
 		prev_tpl_name = stage1_info["emptyTemplates"][step3["count"]-1]
 		prev_tpl_idx = channel_info["templateDict"][prev_tpl_name]["index"]
 		sel_idx = [channel_info["inputDict"][name]["index"] for name in sel_name]
-		stage1_info["mappingResult"][0]["newOrder"][prev_tpl_idx] = sel_idx if sel_idx!=[] else [None]
+		stage1_info["mappingResult"][0]["indices"][prev_tpl_idx] = sel_idx if sel_idx!=[] else [None]
 		#print(prev_tpl_name, '<-', sel_name)
 		
 		# ---------------------------------update the new round---------------------------------
@@ -746,7 +746,7 @@ with gr.Blocks() as demo:
 		label = '{} ({}/{})'.format(tpl_name, step3["count"], step3["totalNum"])
 		
 		tpl_idx = channel_info["templateDict"][tpl_name]["index"]
-		value = stage1_info["mappingResult"][0]["newOrder"][tpl_idx]
+		value = stage1_info["mappingResult"][0]["indices"][tpl_idx]
 		value = [channel_info["inputNames"][i] for i in value]
 		
 		stage1_info["step3"] = step3
@@ -849,7 +849,7 @@ with gr.Blocks() as demo:
 										outputname = outputname,
 										samplerate = int(samplerate),
 										batch_cnt = i,
-										new_idx = stage1_info["mappingResult"][i]["newOrder"],
+										old_idx = stage1_info["mappingResult"][i]["indices"],
 										orig_flags = stage1_info["mappingResult"][i]["isOriginalData"])
 				except FileNotFoundError:
 					print('stop!!')

app_utils.py

@@ -174,7 +174,7 @@ def align_coords(channel_info, tpl_montage, in_montage):
 	})
 	return channel_info
 
-def find_neighbors(channel_info, empty_tpl_names, new_idx):
+def find_neighbors(channel_info, empty_tpl_names, old_idx):
 	in_names = channel_info["inputNames"]
 	tpl_dict = channel_info["templateDict"]
 	in_dict = channel_info["inputDict"]
@@ -189,9 +189,9 @@ def find_neighbors(channel_info, empty_tpl_names, new_idx):
 	for i, name in enumerate(empty_tpl_names):
 		distances, indices = knn.kneighbors(empty_tpl[i].reshape(1,-1))
 		idx = tpl_dict[name]["index"]
-		new_idx[idx] = indices[0].tolist()
+		old_idx[idx] = indices[0].tolist()
     
-	return new_idx
+	return old_idx
 
 def match_names(stage1_info):
     # read the location file
@@ -199,7 +199,7 @@ def match_names(stage1_info):
 	tpl_montage, in_montage, tpl_dict, in_dict = read_montage_data(loc_file)
 	tpl_names = tpl_montage.ch_names
 	in_names = in_montage.ch_names
-	new_idx = [[None]]*30 # store the indices of the in_channels in the order of tpl_channels
+	old_idx = [[None]]*30 # store the indices of the in_channels in the order of tpl_channels
 	orig_flags = [False]*30
 	
 	alias_dict = {
@@ -215,7 +215,7 @@ def match_names(stage1_info):
 			name = alias_dict[name]
 			
 		if name in in_dict:
-			new_idx[i] = [in_dict[name]["index"]]
+			old_idx[i] = [in_dict[name]["index"]]
 			orig_flags[i] = True
 			tpl_dict[name]["matched"] = True
 			in_dict[name]["assigned"] = True
@@ -228,7 +228,7 @@ def match_names(stage1_info):
 	    "emptyTemplates" : get_empty_templates(tpl_names, tpl_dict),
 	    "mappingResult" : [
 		{
-			"newOrder" : new_idx,
+			"indices" : old_idx,
 			"isOriginalData" : orig_flags
 		}
 	    ]
@@ -269,14 +269,14 @@ def optimal_mapping(channel_info):
 	row_idx, col_idx = linear_sum_assignment(cost_matrix)
 	
 	# store the mapping result
-	new_idx = [[None]]*30
+	old_idx = [[None]]*30
 	orig_flags = [False]*30
 	for i, j in zip(row_idx, col_idx):
 		if j < len(unass_in_names): # filter out dummy channels
 			tpl_name = tpl_names[i]
 			in_name = unass_in_names[j]
 			
-			new_idx[i] = [in_dict[in_name]["index"]]
+			old_idx[i] = [in_dict[in_name]["index"]]
 			orig_flags[i] = True
 			tpl_dict[tpl_name]["matched"] = True
 			in_dict[in_name]["assigned"] = True
@@ -285,10 +285,10 @@ def optimal_mapping(channel_info):
 	# fill the remaining empty tpl_channels
 	empty_tpl_names = get_empty_templates(tpl_names, tpl_dict)
 	if empty_tpl_names != []:
-	    new_idx = find_neighbors(channel_info, empty_tpl_names, new_idx)
+	    old_idx = find_neighbors(channel_info, empty_tpl_names, old_idx)
 	
 	result = {
-		"newOrder" : new_idx,
+		"indices" : old_idx,
 		"isOriginalData" : orig_flags
 	}
 	channel_info.update({
@@ -327,14 +327,14 @@ def mapping_result(stage1_info, channel_info, filename):
 	return stage1_info, channel_info
 
 
-def reorder_data(idx_order, orig_flags, inputname, filename):
+def reorder_data(old_idx, orig_flags, inputname, filename):
 	# read the input data
 	raw_data = utils.read_train_data(inputname)
 	#print(raw_data.shape)
 	new_data = np.zeros((30, raw_data.shape[1]))
 	
 	zero_arr = np.zeros((1, raw_data.shape[1]))
-	for i, (indices, flag) in enumerate(zip(idx_order, orig_flags)):
+	for i, (indices, flag) in enumerate(zip(old_idx, orig_flags)):
 		if flag == True:
 			new_data[i, :] = raw_data[indices[0], :]
 		elif indices == [None]:
@@ -346,7 +346,7 @@ def reorder_data(idx_order, orig_flags, inputname, filename):
 	utils.save_data(new_data, filename)
 	return raw_data.shape
 
-def restore_order(batch_cnt, raw_data_shape, idx_order, orig_flags, filename, outputname):
+def restore_order(batch_cnt, raw_data_shape, old_idx, orig_flags, filename, outputname):
 	# read the denoised data
 	d_data = utils.read_train_data(filename)
 	if batch_cnt == 0:
@@ -355,25 +355,25 @@ def restore_order(batch_cnt, raw_data_shape, idx_order, orig_flags, filename, ou
 	else:
 		new_data = utils.read_train_data(outputname)
 	
-	for i, (indices, flag) in enumerate(zip(idx_order, orig_flags)):
+	for i, (indices, flag) in enumerate(zip(old_idx, orig_flags)):
 		if flag == True:
 			new_data[indices[0], :] = d_data[i, :]
 	
 	utils.save_data(new_data, outputname)
 	return
 
-def run_model(modelname, filepath, inputname, m_filename, d_filename, outputname, samplerate, batch_cnt, new_idx, orig_flags):
+def run_model(modelname, filepath, inputname, m_filename, d_filename, outputname, samplerate, batch_cnt, old_idx, orig_flags):
 	# establish temp folder
 	os.mkdir(filepath+'temp_data/')
 	
 	# step1: Reorder input data
-	data_shape = reorder_data(new_idx, orig_flags, inputname, filepath+'temp_data/'+m_filename)
+	data_shape = reorder_data(old_idx, orig_flags, inputname, filepath+'temp_data/'+m_filename)
 	# step2: Data preprocessing
 	total_file_num = utils.preprocessing(filepath+'temp_data/', m_filename, samplerate)
 	# step3: Signal reconstruction
 	utils.reconstruct(modelname, total_file_num, filepath+'temp_data/', d_filename, samplerate)
 	# step4: Restore original order
-	restore_order(batch_cnt, data_shape, new_idx, orig_flags, filepath+'temp_data/'+d_filename, outputname)
+	restore_order(batch_cnt, data_shape, old_idx, orig_flags, filepath+'temp_data/'+d_filename, outputname)
 	
 	utils.dataDelete(filepath+'temp_data/')