update

app.py

@@ -93,8 +93,8 @@ init_js = """
 		item.querySelector(":scope > span").innerText = "";
 	});
 	
-	// add indication for the missing channels
-	channel = stage1_info.missingTemplates[0];
+	// 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];
 	let dot_rule = `
@@ -167,7 +167,7 @@ update_js = """
 	}else return;
 	
 	// update the indication
-	channel = stage1_info.missingTemplates[cnt-1];
+	channel = stage1_info.emptyTemplates[cnt-1];
 	left = channel_info.templateDict[channel].css_position[0];
 	bottom = channel_info.templateDict[channel].css_position[1];
 	let dot_rule = `
@@ -323,7 +323,7 @@ with gr.Blocks() as demo:
 				"totalNum" : None
 	    	},
 	    	"unassignedInputs" : None,
-	    	"missingTemplates" : None,
+	    	"emptyTemplates" : None,
 	    	"batchNum" : None,
 	    	"mappingResults" : [
 	    	{
@@ -404,7 +404,7 @@ with gr.Blocks() as demo:
 		# ========================================step1=========================================
 		elif stage1_info["state"] == "step1-finished":
 			in_num = len(channel_info["inputOrder"])
-			matched_num = 30 - len(stage1_info["missingTemplates"])
+			matched_num = 30 - len(stage1_info["emptyTemplates"])
 			
 			# step1 to step4
 			if matched_num == 30:
@@ -435,9 +435,9 @@ with gr.Blocks() as demo:
 				# initialize the progress indication label
 				stage1_info["step2"] = {
 					"count" : 1,
-					"totalNum" : len(stage1_info["missingTemplates"])
+					"totalNum" : len(stage1_info["emptyTemplates"])
 				}
-				tpl_name = stage1_info["missingTemplates"][0]
+				tpl_name = stage1_info["emptyTemplates"][0]
 				label = '{} (1/{})'.format(tpl_name, stage1_info["step2"]["totalNum"])
 				
 				stage1_info["state"] = "step2-selecting"
@@ -478,7 +478,7 @@ with gr.Blocks() as demo:
 			# --------------------------------store information---------------------------------
 			# if the user has selected an in_channel to forward to the previous target tpl_channel
 			if sel_radio != []:
-				prev_tpl_name = stage1_info["missingTemplates"][stage1_info["step2"]["count"]-1]
+				prev_tpl_name = stage1_info["emptyTemplates"][stage1_info["step2"]["count"]-1]
 				prev_tpl_idx = channel_info["templateDict"][prev_tpl_name]["index"]
 				sel_idx = channel_info["inputDict"][sel_radio]["index"]
 				
@@ -493,11 +493,11 @@ with gr.Blocks() as demo:
 			stage1_info["unassignedInputs"] = app_utils.get_unassigned_inputs(channel_info["inputOrder"],
 																			  channel_info["inputDict"])
 			# exclude the tpl_channels filled in step2
-			stage1_info["missingTemplates"] = app_utils.get_empty_templates(channel_info["templateOrder"],
+			stage1_info["emptyTemplates"] = app_utils.get_empty_templates(channel_info["templateOrder"],
 																			channel_info["templateDict"])
 			# -----------------------------determine the next step------------------------------
 			# step2 to step4
-			if len(stage1_info["missingTemplates"]) == 0:
+			if len(stage1_info["emptyTemplates"]) == 0:
 				md = """
 				### Mapping Results
 				The mapping process has been finished.  
@@ -559,14 +559,14 @@ with gr.Blocks() as demo:
 				# find the 4 nearest in_channels for each unmatched tpl_channels
 				stage1_info["mappingResults"][0]["newOrder"] = app_utils.find_neighbors(
 																		channel_info,
-																		stage1_info["missingTemplates"],
+																		stage1_info["emptyTemplates"],
 																		stage1_info["mappingResults"][0]["newOrder"])
 				# initialize the progress indication label
 				stage1_info["step3"] = {
 					"count" : 1,
-					"totalNum" : len(stage1_info["missingTemplates"])
+					"totalNum" : len(stage1_info["emptyTemplates"])
 				}
-				tpl_name = stage1_info["missingTemplates"][0]
+				tpl_name = stage1_info["emptyTemplates"][0]
 				label = '{} (1/{})'.format(tpl_name, stage1_info["step3"]["totalNum"])
 				
 				tpl_idx = channel_info["templateDict"][tpl_name]["index"]
@@ -596,7 +596,7 @@ with gr.Blocks() as demo:
 		# step3-2 to step4
 		elif stage1_info["state"] == "step3-2-selecting":
 			# --------------------------------store information---------------------------------
-			prev_tpl_name = stage1_info["missingTemplates"][stage1_info["step3"]["count"]-1]
+			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]
 			stage1_info["mappingResults"][0]["newOrder"][prev_tpl_idx] = sel_idx if sel_idx!=[] else [None]
@@ -673,7 +673,7 @@ with gr.Blocks() as demo:
 		# ----------------------------------store information-----------------------------------
 		# if the user has selected an in_channel to forward to the previous target tpl_channel
 		if sel_name != []:
-			prev_tpl_name = stage1_info["missingTemplates"][step2["count"]-1]
+			prev_tpl_name = stage1_info["emptyTemplates"][step2["count"]-1]
 			prev_tpl_idx = channel_info["templateDict"][prev_tpl_name]["index"]
 			sel_idx = channel_info["inputDict"][sel_name]["index"]
 			
@@ -689,7 +689,7 @@ with gr.Blocks() as demo:
 		# exclude the selected in_channel of the previous round
 		stage1_info["unassignedInputs"] = app_utils.get_unassigned_inputs(channel_info["inputOrder"], channel_info["inputDict"])
 		
-		tpl_name = stage1_info["missingTemplates"][step2["count"]-1]
+		tpl_name = stage1_info["emptyTemplates"][step2["count"]-1]
 		label = '{} ({}/{})'.format(tpl_name, step2["count"], step2["totalNum"])
 		
 		stage1_info["step2"] = step2
@@ -724,7 +724,7 @@ with gr.Blocks() as demo:
 	def update_chkbox(stage1_info, channel_info, sel_name):
 		step3 = stage1_info["step3"]
 		# ----------------------------------store information-----------------------------------
-		prev_tpl_name = stage1_info["missingTemplates"][step3["count"]-1]
+		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]
 		stage1_info["mappingResults"][0]["newOrder"][prev_tpl_idx] = sel_idx if sel_idx!=[] else [None]
@@ -733,7 +733,7 @@ with gr.Blocks() as demo:
 		# ---------------------------------update the new round---------------------------------
 		step3["count"] += 1
 		
-		tpl_name = stage1_info["missingTemplates"][step3["count"]-1]
+		tpl_name = stage1_info["emptyTemplates"][step3["count"]-1]
 		label = '{} ({}/{})'.format(tpl_name, step3["count"], step3["totalNum"])
 		
 		tpl_idx = channel_info["templateDict"][tpl_name]["index"]

app_utils.py

@@ -157,7 +157,7 @@ def align_coords(channel_info, tpl_montage, in_montage):
 	in_order = channel_info["inputOrder"]
 	tpl_dict = channel_info["templateDict"]
 	in_dict = channel_info["inputDict"]
-	matched = get_matched(tpl_order, tpl_dict)
+	matched_order = get_matched(tpl_order, 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])
-	matched_in = np.array([all_in[in_dict[channel]["index"]] for channel in matched])
+	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])
 	plt.close('all')
 	
 	# apply TPS to transform in_channels to align with tpl_channels positions
@@ -188,8 +188,8 @@ def align_coords(channel_info, tpl_montage, in_montage):
 	# 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])
-	matched_in = np.array([all_in[in_dict[channel]["index"]] for channel in matched])
+	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])
 	
 	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')
@@ -209,19 +209,19 @@ def align_coords(channel_info, tpl_montage, in_montage):
 	})
 	return channel_info
 
-def find_neighbors(channel_info, missing_channels, new_idx):
+def find_neighbors(channel_info, empty_tpl_order, new_idx):
 	in_order = channel_info["inputOrder"]
 	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 missing_channels]
+	empty_tpl = [np.array(tpl_dict[channel]["coord_3d"]) for channel in empty_tpl_order]
 	
 	# use KNN to choose k nearest channels
 	k = 4 if len(in_order)>4 else len(in_order)
 	knn = NearestNeighbors(n_neighbors=k, metric='euclidean')
 	knn.fit(all_in)
-	for i, channel in enumerate(missing_channels):
+	for i, channel in enumerate(empty_tpl_order):
 		distances, indices = knn.kneighbors(empty_tpl[i].reshape(1,-1))
 		idx = tpl_dict[channel]["index"]
 		new_idx[idx] = indices[0].tolist()
@@ -260,7 +260,7 @@ def match_names(stage1_info):
 	
 	stage1_info.update({
 	    "unassignedInputs" : get_unassigned_inputs(in_order, in_dict),
-	    "missingTemplates" : get_empty_templates(tpl_order, tpl_dict),
+	    "emptyTemplates" : get_empty_templates(tpl_order, tpl_dict),
 	    "mappingResults" : [
 		{
 			"newOrder" : new_idx,
@@ -281,23 +281,23 @@ def optimal_mapping(channel_info):
 	in_order = channel_info["inputOrder"]
 	tpl_dict = channel_info["templateDict"]
 	in_dict = channel_info["inputDict"]
-	unassigned = get_unassigned_inputs(in_order, in_dict)
+	unass_in_order = get_unassigned_inputs(in_order, in_dict)
 	# reset all tpl.matched to False
 	for channel in tpl_dict:
 		tpl_dict[channel]["matched"] = False
 	
 	all_tpl = np.array([tpl_dict[channel]["coord_3d"] for channel in tpl_order])
-	unassigned_in = np.array([in_dict[channel]["coord_3d"] for channel in unassigned])
+	unass_in = np.array([in_dict[channel]["coord_3d"] for channel in unass_in_order])
 	
 	# initialize the cost matrix for the Hungarian algorithm
-	if len(unassigned) < 30:
+	if len(unass_in_order) < 30:
 		cost_matrix = np.full((30, 30), 1e6) # add dummy channels to ensure num_col >= num_row
 	else:
-		cost_matrix = np.zeros((30, len(unassigned)))
+		cost_matrix = np.zeros((30, len(unass_in_order)))
 	# fill the cost matrix with Euclidean distances between tpl and unassigned in_channels
 	for i in range(30):
-		for j in range(len(unassigned)):
-			cost_matrix[i][j] = np.linalg.norm((all_tpl[i]-unassigned_in[j])*1000)
+		for j in range(len(unass_in_order)):
+			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
 	# by minimizing the total distances between their positions.
@@ -307,9 +307,9 @@ 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(unassigned): # filter out dummy channels
+		if j < len(unass_in_order): # filter out dummy channels
 			tpl_channel = tpl_order[i]
-			in_channel = unassigned[j]
+			in_channel = unass_in_order[j]
 			
 			new_idx[i] = [in_dict[in_channel]["index"]]
 			orig_flags[i] = True
@@ -318,9 +318,9 @@ def optimal_mapping(channel_info):
 			#print(f'{tpl_channel}({i}) <- {in_channel}({j})')
 	
 	# fill the remaining empty tpl_channels
-	missing_channels = get_empty_templates(tpl_order, tpl_dict)
-	if missing_channels != []:
-	    new_idx = find_neighbors(channel_info, missing_channels, new_idx)
+	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)
 	
 	result = {
 		"newOrder" : new_idx,