update

app.py

@@ -60,7 +60,7 @@ init_js = """
 	channel_info = JSON.parse(JSON.stringify(channel_info));
 	
 	let selector, attribute;
-	let channel, left, bottom;
+	let name, left, bottom;
 	
 	if(stage1_info.state == "step2-selecting"){
 	    selector = "#radio-group > div:nth-of-type(2)";
@@ -84,9 +84,9 @@ init_js = """
 	// move the radios/checkboxes
 	let all_elem = document.querySelectorAll(selector+" > label");
 	Array.from(all_elem).forEach(item => {
-		channel = item.querySelector("input").getAttribute(attribute);
-		left = channel_info.inputDict[channel].css_position[0];
-		bottom = channel_info.inputDict[channel].css_position[1];
+		name = item.querySelector("input").getAttribute(attribute);
+		left = channel_info.inputDict[name].css_position[0];
+		bottom = channel_info.inputDict[name].css_position[1];
 		
 		item.style.cssText = `position: absolute; left: ${left}; bottom: ${bottom};`;
 		item.className = "";
@@ -94,9 +94,9 @@ init_js = """
 	});
 	
 	// add indication for the empty tpl_channels
-	channel = stage1_info.emptyTemplates[0];
-	left = channel_info.templateDict[channel].css_position[0];
-	bottom = channel_info.templateDict[channel].css_position[1];
+	name = stage1_info.emptyTemplates[0];
+	left = channel_info.templateDict[name].css_position[0];
+	bottom = channel_info.templateDict[name].css_position[1];
 	let dot_rule = `
 		${selector}::before {
 			content: "";
@@ -116,7 +116,7 @@ init_js = """
 	bottom = bottom.toString()+"%";
 	let txt_rule = `
 		${selector}::after {
-			content: "${channel}";
+			content: "${name}";
 			position: absolute;
 			color: red;
 			left: ${left};
@@ -144,7 +144,7 @@ update_js = """
 	channel_info = JSON.parse(JSON.stringify(channel_info));
 	
 	let selector;
-	let cnt, channel, left, bottom;
+	let cnt, name, left, bottom;
 	
 	if(stage1_info.state == "step2-selecting"){
 	    selector = "#radio-group > div:nth-of-type(2)";
@@ -153,9 +153,9 @@ update_js = """
 	    // update the radios
 		let all_elem = document.querySelectorAll(selector+" > label");
 		Array.from(all_elem).forEach(item => {
-			channel = item.querySelector("input").value;
-			left = channel_info.inputDict[channel].css_position[0];
-			bottom = channel_info.inputDict[channel].css_position[1];
+			name = item.querySelector("input").value;
+			left = channel_info.inputDict[name].css_position[0];
+			bottom = channel_info.inputDict[name].css_position[1];
 			
 			item.style.cssText = `position: absolute; left: ${left}; bottom: ${bottom};`;
 			item.className = "";
@@ -167,9 +167,9 @@ update_js = """
 	}else return;
 	
 	// update the indication
-	channel = stage1_info.emptyTemplates[cnt-1];
-	left = channel_info.templateDict[channel].css_position[0];
-	bottom = channel_info.templateDict[channel].css_position[1];
+	name = stage1_info.emptyTemplates[cnt-1];
+	left = channel_info.templateDict[name].css_position[0];
+	bottom = channel_info.templateDict[name].css_position[1];
 	let dot_rule = `
 		${selector}::before {
 			content: "";
@@ -189,7 +189,7 @@ update_js = """
 	bottom = bottom.toString()+"%";
 	let txt_rule = `
 		${selector}::after {
-			content: "${channel}";
+			content: "${name}";
 			position: absolute;
 			color: red;
 			left: ${left};
@@ -403,7 +403,7 @@ with gr.Blocks() as demo:
 		
 		# ========================================step1=========================================
 		elif stage1_info["state"] == "step1-finished":
-			in_num = len(channel_info["inputOrder"])
+			in_num = len(channel_info["inputNames"])
 			matched_num = 30 - len(stage1_info["emptyTemplates"])
 			
 			# step1 to step4
@@ -490,10 +490,10 @@ with gr.Blocks() as demo:
 			
 			# --------------------------------update information--------------------------------
 			# exclude the selected in_channel of the previous round
-			stage1_info["unassignedInputs"] = app_utils.get_unassigned_inputs(channel_info["inputOrder"],
+			stage1_info["unassignedInputs"] = app_utils.get_unassigned_inputs(channel_info["inputNames"],
 																			  channel_info["inputDict"])
 			# exclude the tpl_channels filled in step2
-			stage1_info["emptyTemplates"] = app_utils.get_empty_templates(channel_info["templateOrder"],
+			stage1_info["emptyTemplates"] = app_utils.get_empty_templates(channel_info["templateNames"],
 																			channel_info["templateDict"])
 			# -----------------------------determine the next step------------------------------
 			# step2 to step4
@@ -571,7 +571,7 @@ with gr.Blocks() as demo:
 				
 				tpl_idx = channel_info["templateDict"][tpl_name]["index"]
 				value = stage1_info["mappingResults"][0]["newOrder"][tpl_idx]
-				value = [channel_info["inputOrder"][i] for i in value]
+				value = [channel_info["inputNames"][i] for i in value]
 				
 				stage1_info["state"] = "step3-2-selecting"
 				# determine which button to display
@@ -580,7 +580,7 @@ with gr.Blocks() as demo:
 					        desc_md : gr.Markdown(md),
 							in_fillmode : gr.Dropdown(visible=False),
 				    		fillmode_btn : gr.Button(visible=False),
-				    		chkbox_group : gr.CheckboxGroup(choices=channel_info["inputOrder"],
+				    		chkbox_group : gr.CheckboxGroup(choices=channel_info["inputNames"],
 															value=value, label=label, visible=True),
 				            next_btn : gr.Button(visible=True)}
 				else:
@@ -588,7 +588,7 @@ with gr.Blocks() as demo:
 					        desc_md : gr.Markdown(md),
 							in_fillmode : gr.Dropdown(visible=False),
 				    		fillmode_btn : gr.Button(visible=False),
-				    		chkbox_group : gr.CheckboxGroup(choices=channel_info["inputOrder"],
+				    		chkbox_group : gr.CheckboxGroup(choices=channel_info["inputNames"],
 															value=value, label=label, visible=True),
 				            step3_btn : gr.Button(visible=True)}
 		
@@ -598,7 +598,7 @@ with gr.Blocks() as demo:
 			# --------------------------------store information---------------------------------
 			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"][channel]["index"] for channel in sel_chkbox]
+			sel_idx = [channel_info["inputDict"][name]["index"] for name in sel_chkbox]
 			stage1_info["mappingResults"][0]["newOrder"][prev_tpl_idx] = sel_idx if sel_idx!=[] else [None]
 			#print(prev_tpl_name, '<-', sel_chkbox)
 			# ----------------------------------------------------------------------------------
@@ -687,7 +687,7 @@ with gr.Blocks() as demo:
 		step2["count"] += 1
 		
 		# exclude the selected in_channel of the previous round
-		stage1_info["unassignedInputs"] = app_utils.get_unassigned_inputs(channel_info["inputOrder"], channel_info["inputDict"])
+		stage1_info["unassignedInputs"] = app_utils.get_unassigned_inputs(channel_info["inputNames"], channel_info["inputDict"])
 		
 		tpl_name = stage1_info["emptyTemplates"][step2["count"]-1]
 		label = '{} ({}/{})'.format(tpl_name, step2["count"], step2["totalNum"])
@@ -726,7 +726,7 @@ with gr.Blocks() as demo:
 		# ----------------------------------store information-----------------------------------
 		prev_tpl_name = stage1_info["emptyTemplates"][step3["count"]-1]
 		prev_tpl_idx = channel_info["templateDict"][prev_tpl_name]["index"]
-		sel_idx = [channel_info["inputDict"][channel]["index"] for channel in sel_name]
+		sel_idx = [channel_info["inputDict"][name]["index"] for name in sel_name]
 		stage1_info["mappingResults"][0]["newOrder"][prev_tpl_idx] = sel_idx if sel_idx!=[] else [None]
 		#print(prev_tpl_name, '<-', sel_name)
 		
@@ -738,7 +738,7 @@ with gr.Blocks() as demo:
 		
 		tpl_idx = channel_info["templateDict"][tpl_name]["index"]
 		value = stage1_info["mappingResults"][0]["newOrder"][tpl_idx]
-		value = [channel_info["inputOrder"][i] for i in value]
+		value = [channel_info["inputNames"][i] for i in value]
 		
 		stage1_info["step3"] = step3
 		# determine which button to display

app_utils.py

@@ -46,52 +46,52 @@ def restore_order(batch_cnt, raw_data_shape, idx_order, orig_flags, filename, ou
 	utils.save_data(new_data, outputname)
 	return
 
-def get_matched(tpl_order, tpl_dict):
-    return [channel for channel in tpl_order if tpl_dict[channel]["matched"]==True]
+def get_matched(tpl_names, tpl_dict):
+    return [name for name in tpl_names if tpl_dict[name]["matched"]==True]
 
-def get_empty_templates(tpl_order, tpl_dict):
-    return [channel for channel in tpl_order if tpl_dict[channel]["matched"]==False]
+def get_empty_templates(tpl_names, tpl_dict):
+    return [name for name in tpl_names if tpl_dict[name]["matched"]==False]
 
-def get_unassigned_inputs(in_order, in_dict):
-    return [channel for channel in in_order if in_dict[channel]["assigned"]==False]
+def get_unassigned_inputs(in_names, in_dict):
+    return [name for name in in_names if in_dict[name]["assigned"]==False]
 
 def read_montage_data(loc_file):
 	tpl_montage = read_custom_montage("./template_chanlocs.loc")
 	in_montage = read_custom_montage(loc_file)
-	tpl_order = tpl_montage.ch_names
-	in_order = in_montage.ch_names
+	tpl_names = tpl_montage.ch_names
+	in_names = in_montage.ch_names
 	tpl_dict = {}
 	in_dict = {}
 	
 	# convert all channel names to uppercase and store their information
-	for i, channel in enumerate(tpl_order):
-		up_channel = str.upper(channel)
-		tpl_montage.rename_channels({channel: up_channel})
-		tpl_dict[up_channel] = {
+	for i, name in enumerate(tpl_names):
+		up_name = str.upper(name)
+		tpl_montage.rename_channels({name: up_name})
+		tpl_dict[up_name] = {
 			"index" : i,
-			"coord_3d" : tpl_montage.get_positions()['ch_pos'][up_channel],
+			"coord_3d" : tpl_montage.get_positions()['ch_pos'][up_name],
 			"matched" : False
 		}
-	for i, channel in enumerate(in_order):
-		up_channel = str.upper(channel)
-		in_montage.rename_channels({channel: up_channel})
-		in_dict[up_channel] = {
+	for i, name in enumerate(in_names):
+		up_name = str.upper(name)
+		in_montage.rename_channels({name: up_name})
+		in_dict[up_name] = {
 			"index" : i,
-			"coord_3d" : in_montage.get_positions()['ch_pos'][up_channel],
+			"coord_3d" : in_montage.get_positions()['ch_pos'][up_name],
 			"assigned" : False
 		}
 	return tpl_montage, in_montage, tpl_dict, in_dict
 
 def save_figures(channel_info, tpl_montage, filename1, filename2):
-	tpl_order = channel_info["templateOrder"]
-	in_order = channel_info["inputOrder"]
+	tpl_names = channel_info["templateNames"]
+	in_names = channel_info["inputNames"]
 	tpl_dict = channel_info["templateDict"]
 	in_dict = channel_info["inputDict"]
 	
-	tpl_x = [tpl_dict[channel]["coord_2d"][0] for channel in tpl_order]
-	tpl_y = [tpl_dict[channel]["coord_2d"][1] for channel in tpl_order]
-	in_x = [in_dict[channel]["coord_2d"][0] for channel in in_order]
-	in_y = [in_dict[channel]["coord_2d"][1] for channel in in_order]
+	tpl_x = [tpl_dict[name]["coord_2d"][0] for name in tpl_names]
+	tpl_y = [tpl_dict[name]["coord_2d"][1] for name in tpl_names]
+	in_x = [in_dict[name]["coord_2d"][0] for name in in_names]
+	in_y = [in_dict[name]["coord_2d"][1] for name in in_names]
 	tpl_coords = np.vstack((tpl_x, tpl_y)).T
 	in_coords = np.vstack((in_x, in_y)).T
 	
@@ -116,18 +116,18 @@ def save_figures(channel_info, tpl_montage, filename1, filename2):
 		ax.plot(x, y, color='black', linewidth=1.0)
 	# plot in_channels on it
 	ax.scatter(in_coords[:,0], in_coords[:,1], s=35, color='black')
-	for i, channel in enumerate(in_order):
-		ax.text(in_coords[i,0]+0.003, in_coords[i,1], channel, color='black', fontsize=10.0, va='center')
+	for i, name in enumerate(in_names):
+		ax.text(in_coords[i,0]+0.003, in_coords[i,1], name, color='black', fontsize=10.0, va='center')
 	# save input_montage
 	fig.savefig(filename1)
 	
 	# ---------------------------add indications-------------------------------
 	# plot unmatched input channels in red
-	indices = [in_dict[channel]["index"] for channel in in_order if in_dict[channel]["assigned"]==False]
+	indices = [in_dict[name]["index"] for name in in_names if in_dict[name]["assigned"]==False]
 	if indices != []:
 		ax.scatter(in_coords[indices,0], in_coords[indices,1], s=35, color='red')
 		for i in indices:
-			ax.text(in_coords[i,0]+0.003, in_coords[i,1], in_order[i], color='red', fontsize=10.0, va='center')
+			ax.text(in_coords[i,0]+0.003, in_coords[i,1], in_names[i], color='red', fontsize=10.0, va='center')
 	# save mapped_montage
 	fig.savefig(filename2)
 	
@@ -137,14 +137,14 @@ def save_figures(channel_info, tpl_montage, filename1, filename2):
 	in_coords = ax.transData.transform(in_coords)
 	plt.close('all')
 	
-	for i, channel in enumerate(tpl_order):
+	for i, name in enumerate(tpl_names):
 		css_left = (tpl_coords[i,0]-11)/6.4
 		css_bottom = (tpl_coords[i,1]-7)/6.4
-		tpl_dict[channel]["css_position"] = [str(round(css_left, 2))+"%", str(round(css_bottom, 2))+"%"]
-	for i, channel in enumerate(in_order):
+		tpl_dict[name]["css_position"] = [str(round(css_left, 2))+"%", str(round(css_bottom, 2))+"%"]
+	for i, name in enumerate(in_names):
 		css_left = (in_coords[i,0]-11)/6.4
 		css_bottom = (in_coords[i,1]-7)/6.4
-		in_dict[channel]["css_position"] = [str(round(css_left, 2))+"%", str(round(css_bottom, 2))+"%"]
+		in_dict[name]["css_position"] = [str(round(css_left, 2))+"%", str(round(css_bottom, 2))+"%"]
 	
 	channel_info.update({
 		"templateDict" : tpl_dict,
@@ -153,11 +153,11 @@ def save_figures(channel_info, tpl_montage, filename1, filename2):
 	return channel_info
 
 def align_coords(channel_info, tpl_montage, in_montage):
-	tpl_order = channel_info["templateOrder"]
-	in_order = channel_info["inputOrder"]
+	tpl_names = channel_info["templateNames"]
+	in_names = channel_info["inputNames"]
 	tpl_dict = channel_info["templateDict"]
 	in_dict = channel_info["inputDict"]
-	matched_order = get_matched(tpl_order, tpl_dict)
+	matched_names = get_matched(tpl_names, tpl_dict)
 	
 	# 2D alignment (for visualization purposes)
 	fig = [tpl_montage.plot(), in_montage.plot()]
@@ -166,8 +166,8 @@ def align_coords(channel_info, tpl_montage, in_montage):
 	# extract the displayed 2D coordinates
 	all_tpl = ax[0].collections[0].get_offsets().data
 	all_in= ax[1].collections[0].get_offsets().data
-	matched_tpl = np.array([all_tpl[tpl_dict[channel]["index"]] for channel in matched_order])
-	matched_in = np.array([all_in[in_dict[channel]["index"]] for channel in matched_order])
+	matched_tpl = np.array([all_tpl[tpl_dict[name]["index"]] for name in matched_names])
+	matched_in = np.array([all_in[in_dict[name]["index"]] for name in matched_names])
 	plt.close('all')
 	
 	# apply TPS to transform in_channels to align with tpl_channels positions
@@ -179,17 +179,17 @@ def align_coords(channel_info, tpl_montage, in_montage):
 	transformed_in_y = rbf_y(all_in[:,0], all_in[:,1])
 	transformed_in = np.vstack((transformed_in_x, transformed_in_y)).T
 	
-	for i, channel in enumerate(tpl_order):
-		tpl_dict[channel]["coord_2d"] = all_tpl[i]
-	for i, channel in enumerate(in_order):
-		in_dict[channel]["coord_2d"] = transformed_in[i].tolist()
+	for i, name in enumerate(tpl_names):
+		tpl_dict[name]["coord_2d"] = all_tpl[i]
+	for i, name in enumerate(in_names):
+		in_dict[name]["coord_2d"] = transformed_in[i].tolist()
 	
 	
 	# 3D alignment
-	all_tpl = np.array([tpl_dict[channel]["coord_3d"].tolist() for channel in tpl_order])
-	all_in = np.array([in_dict[channel]["coord_3d"].tolist() for channel in in_order])
-	matched_tpl = np.array([all_tpl[tpl_dict[channel]["index"]] for channel in matched_order])
-	matched_in = np.array([all_in[in_dict[channel]["index"]] for channel in matched_order])
+	all_tpl = np.array([tpl_dict[name]["coord_3d"].tolist() for name in tpl_names])
+	all_in = np.array([in_dict[name]["coord_3d"].tolist() for name in in_names])
+	matched_tpl = np.array([all_tpl[tpl_dict[name]["index"]] for name in matched_names])
+	matched_in = np.array([all_in[in_dict[name]["index"]] for name in matched_names])
 	
 	rbf_x = Rbf(matched_in[:,0], matched_in[:,1], matched_in[:,2], matched_tpl[:,0], function='thin_plate')
 	rbf_y = Rbf(matched_in[:,0], matched_in[:,1], matched_in[:,2], matched_tpl[:,1], function='thin_plate')
@@ -200,8 +200,8 @@ def align_coords(channel_info, tpl_montage, in_montage):
 	transformed_in_z = rbf_z(all_in[:,0], all_in[:,1], all_in[:,2])
 	transformed_in = np.vstack((transformed_in_x, transformed_in_y, transformed_in_z)).T
 	
-	for i, channel in enumerate(in_order):
-		in_dict[channel]["coord_3d"] = transformed_in[i].tolist()
+	for i, name in enumerate(in_names):
+		in_dict[name]["coord_3d"] = transformed_in[i].tolist()
 	
 	channel_info.update({
 	    "templateDict" : tpl_dict,
@@ -209,21 +209,21 @@ def align_coords(channel_info, tpl_montage, in_montage):
 	})
 	return channel_info
 
-def find_neighbors(channel_info, empty_tpl_order, new_idx):
-	in_order = channel_info["inputOrder"]
+def find_neighbors(channel_info, empty_tpl_names, new_idx):
+	in_names = channel_info["inputNames"]
 	tpl_dict = channel_info["templateDict"]
 	in_dict = channel_info["inputDict"]
 	
-	all_in = [np.array(in_dict[channel]["coord_3d"]) for channel in in_order]
-	empty_tpl = [np.array(tpl_dict[channel]["coord_3d"]) for channel in empty_tpl_order]
+	all_in = [np.array(in_dict[name]["coord_3d"]) for name in in_names]
+	empty_tpl = [np.array(tpl_dict[name]["coord_3d"]) for name in empty_tpl_names]
 	
 	# use KNN to choose k nearest channels
-	k = 4 if len(in_order)>4 else len(in_order)
+	k = 4 if len(in_names)>4 else len(in_names)
 	knn = NearestNeighbors(n_neighbors=k, metric='euclidean')
 	knn.fit(all_in)
-	for i, channel in enumerate(empty_tpl_order):
+	for i, name in enumerate(empty_tpl_names):
 		distances, indices = knn.kneighbors(empty_tpl[i].reshape(1,-1))
-		idx = tpl_dict[channel]["index"]
+		idx = tpl_dict[name]["index"]
 		new_idx[idx] = indices[0].tolist()
     
 	return new_idx
@@ -232,8 +232,8 @@ def match_names(stage1_info):
     # read the location file
 	loc_file = stage1_info["fileNames"]["inputLocation"]
 	tpl_montage, in_montage, tpl_dict, in_dict = read_montage_data(loc_file)
-	tpl_order = tpl_montage.ch_names
-	in_order = in_montage.ch_names
+	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
 	orig_flags = [False]*30
 	
@@ -243,24 +243,24 @@ def match_names(stage1_info):
 		'T5': 'P7',
 		'T6': 'P8'
 	}
-	for i, channel in enumerate(tpl_order):
-		if channel in alias_dict and alias_dict[channel] in in_dict:
-			tpl_montage.rename_channels({channel: alias_dict[channel]})
-			tpl_dict[alias_dict[channel]] = tpl_dict.pop(channel)
-			channel = alias_dict[channel]
+	for i, name in enumerate(tpl_names):
+		if name in alias_dict and alias_dict[name] in in_dict:
+			tpl_montage.rename_channels({name: alias_dict[name]})
+			tpl_dict[alias_dict[name]] = tpl_dict.pop(name)
+			name = alias_dict[name]
 			
-		if channel in in_dict:
-			new_idx[i] = [in_dict[channel]["index"]]
+		if name in in_dict:
+			new_idx[i] = [in_dict[name]["index"]]
 			orig_flags[i] = True
-			tpl_dict[channel]["matched"] = True
-			in_dict[channel]["assigned"] = True
+			tpl_dict[name]["matched"] = True
+			in_dict[name]["assigned"] = True
 	
 	# update the names
-	tpl_order = tpl_montage.ch_names
+	tpl_names = tpl_montage.ch_names
 	
 	stage1_info.update({
-	    "unassignedInputs" : get_unassigned_inputs(in_order, in_dict),
-	    "emptyTemplates" : get_empty_templates(tpl_order, tpl_dict),
+	    "unassignedInputs" : get_unassigned_inputs(in_names, in_dict),
+	    "emptyTemplates" : get_empty_templates(tpl_names, tpl_dict),
 	    "mappingResults" : [
 		{
 			"newOrder" : new_idx,
@@ -269,34 +269,34 @@ def match_names(stage1_info):
 	    ]
 	})
 	channel_info = {
-		"templateOrder" : tpl_order,
-		"inputOrder" : in_order,
+		"templateNames" : tpl_names,
+		"inputNames" : in_names,
 	    "templateDict" : tpl_dict,
 	    "inputDict" : in_dict
 	}
 	return stage1_info, channel_info, tpl_montage, in_montage
 
 def optimal_mapping(channel_info):
-	tpl_order = channel_info["templateOrder"]
-	in_order = channel_info["inputOrder"]
+	tpl_names = channel_info["templateNames"]
+	in_names = channel_info["inputNames"]
 	tpl_dict = channel_info["templateDict"]
 	in_dict = channel_info["inputDict"]
-	unass_in_order = get_unassigned_inputs(in_order, in_dict)
+	unass_in_names = get_unassigned_inputs(in_names, in_dict)
 	# reset all tpl.matched to False
-	for channel in tpl_dict:
-		tpl_dict[channel]["matched"] = False
+	for name in tpl_dict:
+		tpl_dict[name]["matched"] = False
 	
-	all_tpl = np.array([tpl_dict[channel]["coord_3d"] for channel in tpl_order])
-	unass_in = np.array([in_dict[channel]["coord_3d"] for channel in unass_in_order])
+	all_tpl = np.array([tpl_dict[name]["coord_3d"] for name in tpl_names])
+	unass_in = np.array([in_dict[name]["coord_3d"] for name in unass_in_names])
 	
 	# initialize the cost matrix for the Hungarian algorithm
-	if len(unass_in_order) < 30:
+	if len(unass_in_names) < 30:
 		cost_matrix = np.full((30, 30), 1e6) # add dummy channels to ensure num_col >= num_row
 	else:
-		cost_matrix = np.zeros((30, len(unass_in_order)))
+		cost_matrix = np.zeros((30, len(unass_in_names)))
 	# fill the cost matrix with Euclidean distances between tpl and unassigned in_channels
 	for i in range(30):
-		for j in range(len(unass_in_order)):
+		for j in range(len(unass_in_names)):
 			cost_matrix[i][j] = np.linalg.norm((all_tpl[i]-unass_in[j])*1000)
 	
 	# apply the Hungarian algorithm to optimally assign one in_channel to each tpl_channel
@@ -307,20 +307,20 @@ def optimal_mapping(channel_info):
 	new_idx = [[None]]*30
 	orig_flags = [False]*30
 	for i, j in zip(row_idx, col_idx):
-		if j < len(unass_in_order): # filter out dummy channels
-			tpl_channel = tpl_order[i]
-			in_channel = unass_in_order[j]
+		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_channel]["index"]]
+			new_idx[i] = [in_dict[in_name]["index"]]
 			orig_flags[i] = True
-			tpl_dict[tpl_channel]["matched"] = True
-			in_dict[in_channel]["assigned"] = True
-			#print(f'{tpl_channel}({i}) <- {in_channel}({j})')
+			tpl_dict[tpl_name]["matched"] = True
+			in_dict[in_name]["assigned"] = True
+			#print(f'{tpl_name}({i}) <- {in_name}({j})')
 	
 	# fill the remaining empty tpl_channels
-	empty_tpl_order = get_empty_templates(tpl_order, tpl_dict)
-	if empty_tpl_order != []:
-	    new_idx = find_neighbors(channel_info, empty_tpl_order, new_idx)
+	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)
 	
 	result = {
 		"newOrder" : new_idx,
@@ -344,8 +344,8 @@ def mapping_result(stage1_info, channel_info, filename):
 		results += [result]
 	
 	data = {
-		#"templateOrder" : channel_info["templateOrder"],
-		#"inputOrder" : channel_info["inputOrder"],
+		#"templateNames" : channel_info["templateNames"],
+		#"inputNames" : channel_info["inputNames"],
 		"batchNum" : batch_num,
 		"mappingResults" : results
 	}