update

app.py

@@ -14,11 +14,9 @@ This tool is designed to assist you with two main tasks:
 - **Channel locations**: If you don't have the channel location file, we recommend you to download the standard montage <a href="">here</a>. If the channels in those files don't match yours, you can use **EEGLAB** to adjust them to your required montage.
 - **Raw data**: Your data format must be a two-dimensional array (channels, timepoints).
 - **Channel requirements**: Your data must include some channels that correspond to our template channels, which include: ``Fp1, Fp2, F7, F3, Fz, F4, F8, FT7, FC3, FCz, FC4, FT8, T7, C3, Cz, C4, T8, TP7, CP3, CPz, CP4, TP8, P7, P3, Pz, P4, P8, O1, Oz, O2``. At least some of them need to be present for successful mapping. Additionally, please remove any reference, ECG, EOG, EMG... channels before uploading your files.
-
 """
 
 readme = """
-
 ## 1. Channel Mapping
 The following steps will guide you through the process of mapping your EEG channels to our template channels.
 
@@ -44,10 +42,10 @@ Once all template channels are filled, you will be directed to **Mapping Results
 ### Mapping Results
 After completing the previous steps, your channels will be aligned with the template channels required by our models.
 - In case there are still some channels that haven't been mapped, we will automatically batch and optimally assign them to the template. This ensures that even channels not initially mapped will still be included in the final results.
-- Once the mapping process is completed, a **JSON file** containing the mapping results will be generated. This file is necessary only if you plan to run the models using the <a href="">source code</a>; otherwise, you can ignore it.
+- Once the mapping process is completed, a JSON file containing the mapping results will be generated. This file is necessary only if you plan to run the models using the <a href="">source code</a>; otherwise, you can ignore it.
 
 ## 2. Decode data
-After clicking on ``Run`` button, we will process your EEG data based on the mapping results. If necessary, your data will be devided into batches and run the models on each batch sequentially, ensuring that all channels are properly processed.
+After clicking on ``Run`` button, we will process your EEG data based on the mapping results. If necessary, your data will be divided into batches and run the models on each batch sequentially, ensuring that all channels are properly processed.
 """
 
 icunet = """
@@ -62,14 +60,16 @@ init_js = """
 	channel_info = JSON.parse(JSON.stringify(channel_info));
 	stage1_info = app_info.stage1
 	
-	let selector, attribute;
+	let selector, attribute; //, classname;
 	let channel, left, bottom;
 	
 	if(stage1_info.state == "step2-selecting"){
 	    selector = "#radio-group > div:nth-of-type(2)";
+	    //classname = "radio";
 	    attribute = "value";
 	}else if(stage1_info.state == "step3-2-selecting"){
 	    selector = "#chkbox-group > div:nth-of-type(2)";
+	     //classname = "chkbox";
 	    attribute = "name";
 	}else return;
 	
@@ -93,7 +93,7 @@ init_js = """
 		bottom = channel_info.inputDict[channel].css_position[1];
 		
 		item.style.cssText = `position: absolute; left: ${left}; bottom: ${bottom};`;
-		item.className = "";
+		item.className = ""; //classname;
 		item.querySelector(":scope > span").innerText = "";
 	});
 	
@@ -217,21 +217,22 @@ update_js = """
 """
 
 with gr.Blocks() as demo:
-
 	app_info_json = gr.JSON(visible=False)
 	channel_info_json = gr.JSON(visible=False)
 
 	gr.Markdown(intro)
 	with gr.Row():
 
-		with gr.Column(variant='panel'):
+		with gr.Column(variant="panel"):
 			gr.Markdown("# 1.Channel Mapping")
-			# --------------------input----------------------
+			# ---------------------input---------------------
 			in_loc_file = gr.File(label="Channel locations (.loc, .locs, .xyz, .sfp, .txt)",
 							file_types=[".loc", "locs", ".xyz", ".sfp", ".txt"])
 			map_btn = gr.Button("Map")
-			# -------------------mapping---------------------
+			# ---------------------output--------------------
 			desc_md = gr.Markdown(visible=False)
+			out_json_file = gr.File(visible=False)
+			# --------------------mapping--------------------
 			# step1 : initial matching and scaling
 			with gr.Row():
 				tpl_img = gr.Image("./template_montage.png", label="Template montage", visible=False)
@@ -247,24 +248,17 @@ with gr.Blocks() as demo:
 											scale=2)
 				fillmode_btn = gr.Button("OK", visible=False, scale=1)
 			chkbox_group = gr.CheckboxGroup(elem_id="chkbox-group", visible=False)
-			# step4 : mapping results
-			out_json_file = gr.File(visible=False)
-			res_md = gr.Markdown(
-					"""
-					(Download this file if you plan to run the models using the <a href="">source code</a>.)
-					""",
-					visible=False)
-					
+			
 			with gr.Row():
 				clear_btn = gr.Button("Clear", visible=False)
 				step2_btn = gr.Button("Next", visible=False)
 				step3_btn = gr.Button("Next", visible=False)
 				next_btn = gr.Button("Next step", visible=False)
 			# -----------------------------------------------
-
-		with gr.Column(variant='panel'):
+		
+		with gr.Column(variant="panel"):
 			gr.Markdown("# 2.Decode Data")
-			# --------------------input----------------------
+			# ---------------------input---------------------
 			with gr.Row():
 				in_data_file = gr.File(label="Raw data (.csv)", file_types=[".csv"])
 				with gr.Column():
@@ -274,15 +268,17 @@ with gr.Blocks() as demo:
 										("IC-U-Net", "ICUNet"),
 										("IC-U-Net++", "UNetpp"),
 										("IC-U-Net-Attn", "AttUnet")],
-										#"(mapped data)"],
+										#"(mapped data)",
+										#"(denoised data)"],
 										value="EEGART",
 										label="Model")
-					run_btn = gr.Button(interactive=False)
-			# --------------------output---------------------
+					run_btn = gr.Button("Run", interactive=False)
+					cancel_btn = gr.Button("Cancel", visible=False)
+			# ---------------------output--------------------
 			batch_md = gr.Markdown(visible=False)
 			out_data_file = gr.File(label="Denoised data", visible=False)
 			# -----------------------------------------------
-				
+			
 	with gr.Row():
 		with gr.Tab("README"):
 			gr.Markdown(readme)
@@ -340,8 +336,8 @@ with gr.Blocks() as demo:
 					"input_data" : "",
 					"output_data" : ""
 				},
-				"sampleRate" : None,
-				"totalBatchNum" : None
+				"totalBatchNum" : None,
+				"sampleRate" : None
 			}
 		}
 		return {app_info_json : app_info,
@@ -360,11 +356,11 @@ with gr.Blocks() as demo:
 				chkbox_group : gr.CheckboxGroup(choices=[], value=[], label="", visible=False),
 				step3_btn : gr.Button(visible=False),
 				out_json_file : gr.File(value=None, visible=False),
-				res_md : gr.Markdown(visible=False),
 				# --------------------Stage2-------------------------
 				in_data_file : gr.File(value=None),
 				in_samplerate : gr.Textbox(value=None),
 				run_btn : gr.Button(interactive=False),
+				cancel_btn : gr.Button(interactive=False),
 				batch_md : gr.Markdown(visible=False),
 				out_data_file : gr.File(value=None, visible=False)}
 	
@@ -427,7 +423,8 @@ with gr.Blocks() as demo:
 			if matched_num == 30:
 				md = """
 				### Mapping Results
-				The mapping process has been finished.
+				The mapping process has been finished.  
+				Download the file below if you plan to run the models using the <a href="">source code</a>.
 				"""
 				# finalize and save the mapping results
 				filename = filepath+"mapping_result.json"
@@ -443,7 +440,6 @@ with gr.Blocks() as demo:
 						mapped_img : gr.Image(visible=False),
 						next_btn : gr.Button(visible=False),
 						out_json_file : gr.File(filename, visible=True),
-						res_md : gr.Markdown(visible=True),
 						run_btn : gr.Button(interactive=True)}
 			
 			# step1 to step2
@@ -487,7 +483,7 @@ with gr.Blocks() as demo:
 			elif in_num == matched_num:
 				md = """
 				### Step3: Filling Remaining Template Channels
-				Select one of the methods provided below to fill the remaining empty template channels.
+				Select one of the methods provided below to fill the remaining template channels.
 				"""
 				stage1_info["state"] = "step3-select-method"
 				app_info["stage1"] = stage1_info
@@ -503,7 +499,7 @@ with gr.Blocks() as demo:
 		elif stage1_info["state"] == "step2-selecting":
 		
 			# --------------------store information before the button click---------------------
-			# check if the user has selected an in_channel to forward to the previous target tpl_channel
+			# if the user has selected an in_channel to forward to the previous target tpl_channel
 			if selected_radio != []:
 				prev_target_name = stage1_info["missingTemplates"][stage1_info["fillingCount"]-1]
 				prev_target_idx = channel_info["templateDict"][prev_target_name]["index"]
@@ -528,7 +524,8 @@ with gr.Blocks() as demo:
 			if len(stage1_info["missingTemplates"]) == 0:
 				md = """
 				### Mapping Results
-				The mapping process has been finished.
+				The mapping process has been finished.  
+				Download the file below if you plan to run the models using the <a href="">source code</a>.
 				"""
 				# finalize and save the mapping results
 				filename = filepath+"mapping_result.json"
@@ -542,7 +539,6 @@ with gr.Blocks() as demo:
 						desc_md : gr.Markdown(md),
 						radio_group : gr.Radio(visible=False),
 						out_json_file : gr.File(filename, visible=True),
-						res_md : gr.Markdown(visible=True),
 						clear_btn : gr.Button(visible=False),
 						next_btn : gr.Button(visible=False),
 						run_btn : gr.Button(interactive=True)}
@@ -550,7 +546,7 @@ with gr.Blocks() as demo:
 			else:
 				md = """
 				### Step3: Filling Remaining Template Channels
-				Select one of the methods provided below to fill the remaining empty template channels.
+				Select one of the methods provided below to fill the remaining template channels.
 				"""
 				stage1_info["state"] = "step3-select-method"
 				app_info["stage1"] = stage1_info
@@ -570,7 +566,8 @@ with gr.Blocks() as demo:
 			if fillmode == "zero":
 				md = """
 				### Mapping Results
-				The mapping process has been finished.
+				The mapping process has been finished.  
+				Download the file below if you plan to run the models using the <a href="">source code</a>.
 				"""
 				# finalize and save the mapping results
 				filename = filepath+"mapping_result.json"
@@ -585,7 +582,6 @@ with gr.Blocks() as demo:
 						in_fillmode : gr.Dropdown(visible=False),
 						fillmode_btn : gr.Button(visible=False),
 						out_json_file : gr.File(filename, visible=True),
-						res_md : gr.Markdown(visible=True),
 						run_btn : gr.Button(interactive=True)}
 			# step3-1 to step3-2
 			elif fillmode == "mean":
@@ -636,18 +632,16 @@ with gr.Blocks() as demo:
 		elif stage1_info["state"] == "step3-2-selecting":
 			
 			# --------------------store information before the button click---------------------
-			# check if the user didn't uncheck all in_channel checkboxes
-			if selected_chkbox != []:
-				prev_target_name = stage1_info["missingTemplates"][stage1_info["fillingCount"]-1]
-				prev_target_idx = channel_info["templateDict"][prev_target_name]["index"]
-				selected_indices = [channel_info["inputDict"][channel]["index"] for channel in selected_chkbox]
-				
-				stage1_info["mappingData"][0]["newOrder"][prev_target_idx] = selected_indices
-				#print(f'{prev_target_name}({prev_target_idx}): {selected_indices}')
+			prev_target_name = stage1_info["missingTemplates"][stage1_info["fillingCount"]-1]
+			prev_target_idx = channel_info["templateDict"][prev_target_name]["index"]
+			selected_indices = [channel_info["inputDict"][channel]["index"] for channel in selected_chkbox]
+			stage1_info["mappingData"][0]["newOrder"][prev_target_idx] = selected_indices
+			#print(f'{prev_target_name}({prev_target_idx}): {selected_indices}')
 			# ----------------------------------------------------------------------------------
 			md = """
 			### Mapping Results
-			The mapping process has been finished.
+			The mapping process has been finished.  
+			Download the file below if you plan to run the models using the <a href="">source code</a>.
 			"""
 			# finalize and save the mapping results
 			filename = filepath+"mapping_result.json"
@@ -662,14 +656,13 @@ with gr.Blocks() as demo:
 					chkbox_group : gr.CheckboxGroup(visible=False),
 					next_btn : gr.Button(visible=False),
 					out_json_file : gr.File(filename, visible=True),
-					res_md : gr.Markdown(visible=True),
 					run_btn : gr.Button(interactive=True)}
 	
 	next_btn.click(
 		fn = init_next_step,
 		inputs = [app_info_json, channel_info_json, in_fillmode, radio_group, chkbox_group],
 		outputs = [app_info_json, channel_info_json, desc_md, tpl_img, mapped_img, radio_group, clear_btn, step2_btn,
-		            in_fillmode, fillmode_btn, chkbox_group, step3_btn, out_json_file, res_md, next_btn, run_btn]
+		            in_fillmode, fillmode_btn, chkbox_group, step3_btn, out_json_file, next_btn, run_btn]
 	).success(
 	    fn = None,
 	    js = init_js,
@@ -686,7 +679,7 @@ with gr.Blocks() as demo:
 	    inputs = in_loc_file,
 	    outputs = [app_info_json, channel_info_json, map_btn, desc_md, next_btn, tpl_img, mapped_img,
 	    			radio_group, clear_btn, step2_btn, in_fillmode, fillmode_btn, chkbox_group, step3_btn,
-	    			out_json_file, res_md, in_data_file, in_samplerate, run_btn, batch_md, out_data_file]
+	    			out_json_file, in_data_file, in_samplerate, run_btn, cancel_btn, batch_md, out_data_file]
 	).success(
 	    fn = init_next_step,
 	    inputs = [app_info_json, channel_info_json, in_fillmode, radio_group, chkbox_group], 
@@ -720,7 +713,7 @@ with gr.Blocks() as demo:
 	def update_radio(app_info, channel_info, selected):
 		stage1_info = app_info["stage1"]
 		# ----------------------store information before the button click-----------------------
-		# check if the user has selected an in_channel to forward to the previous target tpl_channel
+		# if the user has selected an in_channel to forward to the previous target tpl_channel
 		if selected != []:
 			prev_target_name = stage1_info["missingTemplates"][stage1_info["fillingCount"]-1]
 			prev_target_idx = channel_info["templateDict"][prev_target_name]["index"]
@@ -774,14 +767,11 @@ with gr.Blocks() as demo:
 	def update_chkbox(app_info, channel_info, selected):
 		stage1_info = app_info["stage1"]
 		# ----------------------store information before the button click-----------------------
-		# check if the user didn't uncheck all in_channel checkboxes
-		if selected != []:
-			prev_target_name = stage1_info["missingTemplates"][stage1_info["fillingCount"]-1]
-			prev_target_idx = channel_info["templateDict"][prev_target_name]["index"]
-			selected_indices = [channel_info["inputDict"][channel]["index"] for channel in selected]
-			
-			stage1_info["mappingData"][0]["newOrder"][prev_target_idx] = selected_indices
-			#print(f'{prev_target_name}({prev_target_idx}): {selected_indices}')
+		prev_target_name = stage1_info["missingTemplates"][stage1_info["fillingCount"]-1]
+		prev_target_idx = channel_info["templateDict"][prev_target_name]["index"]
+		selected_indices = [channel_info["inputDict"][channel]["index"] for channel in selected]
+		stage1_info["mappingData"][0]["newOrder"][prev_target_idx] = selected_indices
+		#print(f'{prev_target_name}({prev_target_idx}): {selected_indices}')
 		
 		# ------------------------update information for the new round--------------------------
 		stage1_info["fillingCount"] += 1
@@ -808,7 +798,7 @@ with gr.Blocks() as demo:
 	    fn = init_next_step,
 		inputs = [app_info_json, channel_info_json, in_fillmode, radio_group, chkbox_group],
 		outputs = [app_info_json, channel_info_json, desc_md, in_fillmode, fillmode_btn, chkbox_group, step3_btn,
-					out_json_file, res_md, next_btn, run_btn]
+					out_json_file, next_btn, run_btn]
 	).success(
 	    fn = None,
 	    js = init_js,
@@ -855,8 +845,9 @@ with gr.Blocks() as demo:
 		})
 		app_info["stage2"] = stage2_info
 		return {app_info_json : app_info,
-				#run_btn : gr.Button(interactive=False),
-				batch_md : gr.Markdown(visible=False),
+				run_btn : gr.Button(visible=False),
+				cancel_btn : gr.Button(visible=True, interactive=True),
+				batch_md : gr.Markdown("", visible=True),
 				out_data_file : gr.File(visible=False)}
 	
 	def run_model(app_info, modelname):
@@ -873,19 +864,14 @@ with gr.Blocks() as demo:
 			# establish a temp folder
 			try:
 				os.mkdir(filepath+"temp_data/")
-			#except FileExistsError:
-				#utils.dataDelete(filepath+"temp_data/")
-				#os.mkdir(filepath+"temp_data/")
 			except FileNotFoundError:
 				print('break1')
 				break_flag = True
 				break
-			except OSError as e:
-				print(e)
 			
 			# update the running status
 			md = "Running model({}/{})...".format(i+1, stage2_info["totalBatchNum"])
-			yield {batch_md : gr.Markdown(md, visible=True)}
+			yield {batch_md : gr.Markdown(md)}
 			
 			# get the mapped index order and the filled status for each tpl_channels
 			new_idx = stage1_info["mappingData"][i]["newOrder"]
@@ -908,23 +894,29 @@ with gr.Blocks() as demo:
 			utils.dataDelete(filepath+"temp_data/")
 		
 		if break_flag == True:
-			yield {batch_md : gr.Markdown(visible=False)}
+			yield {run_btn : gr.Button(visible=True),
+					cancel_btn : gr.Button(visible=False)}
 		else:
-			yield {#run_btn : gr.Button(interactive=True),
+			yield {run_btn : gr.Button(visible=True),
+					cancel_btn : gr.Button(visible=False),
 					batch_md : gr.Markdown(visible=False),
 					out_data_file : gr.File(new_filename, visible=True)}
 	
+	@cancel_btn.click(inputs = app_info_json, outputs = [cancel_btn, batch_md])
+	def stop_processing(app_info):
+		utils.dataDelete(app_info["stage2"]["filePath"])
+		return gr.Button(interactive=False), gr.Markdown(visible=False)
+	
 	run_btn.click(
 		fn = reset_run,
 		inputs = [app_info_json, in_data_file, in_samplerate, in_modelname],
-		outputs = [app_info_json, run_btn, batch_md, out_data_file]
-		
+		outputs = [app_info_json, run_btn, cancel_btn, batch_md, out_data_file]
 	).success(
 		fn = run_model,
 		inputs = [app_info_json, in_modelname],
-		outputs = [run_btn, batch_md, out_data_file]
+		outputs = [run_btn, cancel_btn, batch_md, out_data_file]
 	)
 	
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(server_name="0.0.0.0", server_port=7860)
 

app_utils.py

@@ -1,358 +1,359 @@
-import utils
-import os
-import math
-import json
-import numpy as np
-import matplotlib.pyplot as plt
-import mne
-from mne.channels import read_custom_montage
-from scipy.interpolate import Rbf
-from scipy.optimize import linear_sum_assignment
-from sklearn.neighbors import NearestNeighbors
-
-def reorder_data(idx_order, fill_flags, filename, new_filename):
-	# read the input data
-	raw_data = utils.read_train_data(filename)
-	#print(raw_data.shape)
-	new_data = np.zeros((30, raw_data.shape[1]))
-	
-	zero_arr = np.zeros((1, raw_data.shape[1]))
-	for i, (idx_set, flag) in enumerate(zip(idx_order, fill_flags)):
-		if flag == False:
-			new_data[i, :] = raw_data[idx_set[0], :]
-		elif idx_set == []:
-			new_data[i, :] = zero_arr
-		else:
-			tmp_data = [raw_data[j, :] for j in idx_set]
-			new_data[i, :] = np.mean(tmp_data, axis=0)
-	
-	utils.save_data(new_data, new_filename)
-	return raw_data.shape
-
-def restore_order(batch_cnt, raw_data_shape, idx_order, fill_flags, filename, new_filename):
-	# read the denoised data
-	d_data = utils.read_train_data(filename)
-	if batch_cnt == 0:
-		new_data = np.zeros((raw_data_shape[0], d_data.shape[1]))
-		#print(new_data.shape)
-	else:
-		new_data = utils.read_train_data(new_filename)
-	
-	for i, (idx_set, flag) in enumerate(zip(idx_order, fill_flags)):
-		# ignore if this channel was filled using "fillmode"
-		if flag == False:
-			new_data[idx_set[0], :] = d_data[i, :]
-	
-	utils.save_data(new_data, new_filename)
-	return
-
-def get_matched(tpl_order, tpl_dict):
-    return [channel for channel in tpl_order if tpl_dict[channel]["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_unassigned_inputs(in_order, in_dict):
-    return [channel for channel in in_order if in_dict[channel]["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_dict = {}
-	in_dict = {}
-	
-	# convert all channel names to uppercase and store the channel information
-	for i, channel in enumerate(tpl_order):
-		up_channel = str.upper(channel)
-		tpl_montage.rename_channels({channel: up_channel})
-		tpl_dict[up_channel] = {
-			"index" : i,
-			"coord_3d" : tpl_montage.get_positions()['ch_pos'][up_channel],
-			"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] = {
-			"index" : i,
-			"coord_3d" : in_montage.get_positions()['ch_pos'][up_channel],
-			"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_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_coords = np.vstack((tpl_x, tpl_y)).T
-	in_coords = np.vstack((in_x, in_y)).T
-	
-	# extract template's head figure
-	tpl_fig = tpl_montage.plot()
-	tpl_ax = tpl_fig.axes[0]
-	lines = tpl_ax.lines
-	head_lines = []
-	for line in lines:
-		x, y = line.get_data()
-		head_lines.append((x,y))
-	plt.close()
-	
-	# -------------------------plot input montage------------------------------
-	fig = plt.figure(figsize=(6.4,6.4), dpi=100)
-	ax = fig.add_subplot(111)
-	fig.tight_layout()
-	ax.set_aspect('equal')
-	ax.axis('off')
-	
-	# plot template's head
-	for x, y in head_lines:
-		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')
-	# 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]
-	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')
-	# save mapped_montage
-	fig.savefig(filename2)
-	
-	# -------------------------------------------------------------------------
-	# store the tpl and in_channels' display positions (in px).
-	tpl_coords = ax.transData.transform(tpl_coords)
-	in_coords = ax.transData.transform(in_coords)
-	plt.close()
-	
-	for i, channel in enumerate(tpl_order):
-		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):
-		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))+"%"]
-	
-	channel_info.update({
-		"templateDict" : tpl_dict,
-		"inputDict" : in_dict
-	})
-	return channel_info
-
-def align_coords(channel_info, tpl_montage, in_montage):
-	tpl_order = channel_info["templateOrder"]
-	in_order = channel_info["inputOrder"]
-	tpl_dict = channel_info["templateDict"]
-	in_dict = channel_info["inputDict"]
-	matched = get_matched(tpl_order, tpl_dict)
-	
-	# 2D alignment (for visualization purposes)
-	fig = [tpl_montage.plot(), in_montage.plot()]
-	ax = [fig[0].axes[0], fig[1].axes[0]]
-	
-	# extract the displayed 2D coordinates from the plots
-	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])
-	
-	# apply TPS to transform in_channels positions to align with tpl_channels positions
-	rbf_x = Rbf(matched_in[:,0], matched_in[:,1], matched_tpl[:,0], function='thin_plate')
-	rbf_y = Rbf(matched_in[:,0], matched_in[:,1], matched_tpl[:,1], function='thin_plate')
-	
-	# apply the transformation to all in_channels
-	transformed_in_x = rbf_x(all_in[:,0], all_in[:,1])
-	transformed_in_y = rbf_y(all_in[:,0], all_in[:,1])
-	transformed_in = np.vstack((transformed_in_x, transformed_in_y)).T
-	
-	# store the 2D positions
-	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()
-	
-	
-	# 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])
-	
-	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')
-	rbf_z = Rbf(matched_in[:,0], matched_in[:,1], matched_in[:,2], matched_tpl[:,2], function='thin_plate')
-	
-	transformed_in_x = rbf_x(all_in[:,0], all_in[:,1], all_in[:,2])
-	transformed_in_y = rbf_y(all_in[:,0], all_in[:,1], all_in[:,2])
-	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
-	
-	# update in_channels' 3D positions
-	for i, channel in enumerate(in_order):
-		in_dict[channel]["coord_3d"] = transformed_in[i].tolist()
-	
-	channel_info.update({
-	    "templateDict" : tpl_dict,
-	    "inputDict" : in_dict
-	})
-	return channel_info
-
-def find_neighbors(channel_info, missing_channels, 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]
-	
-	# 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):
-		distances, indices = knn.kneighbors(empty_tpl[i].reshape(1,-1))
-		idx = tpl_dict[channel]["index"]
-		new_idx[idx] = indices[0].tolist()
-    
-	return new_idx
-
-def match_names(stage1_info, channel_info):
-    # read the location file
-	loc_file = stage1_info["fileNames"]["input_loc"]
-	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
-	new_idx = [[]]*30 # store the indices of the in_channels in the order of tpl_channels
-	fill_flags = [True]*30 # record if each tpl_channel's data is filled by "fillmode"
-	
-	alias_dict = {
-		'T3': 'T7',
-		'T4': 'T8',
-		'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]
-			
-		if channel in in_dict:
-			new_idx[i] = [in_dict[channel]["index"]]
-			fill_flags[i] = False
-			tpl_dict[channel]["matched"] = True
-			in_dict[channel]["assigned"] = True
-	
-	# update the names
-	tpl_order = tpl_montage.ch_names
-	
-	stage1_info.update({
-	    "unassignedInputs" : get_unassigned_inputs(in_order, in_dict),
-	    "missingTemplates" : get_empty_templates(tpl_order, tpl_dict),
-	    "mappingData" : [
-		{
-			"newOrder" : new_idx,
-			"fillFlags" : fill_flags
-		}
-	    ]
-	})
-	channel_info.update({
-		"templateOrder" : tpl_order,
-		"inputOrder" : in_order,
-	    "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_dict = channel_info["templateDict"]
-	in_dict = channel_info["inputDict"]
-	unassigned = 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])
-	
-	# initialize the cost matrix for the Hungarian algorithm
-	if len(unassigned) < 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)))
-	# fill the cost matrix with Euclidean distances between tpl_channels 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)
-	
-	# apply the Hungarian algorithm to optimally assign one in_channel to each tpl_channel
-	# by minimizing the total distances between their positions.
-	row_idx, col_idx = linear_sum_assignment(cost_matrix)
-	
-	# store the mapping results
-	new_idx = [[]]*30
-	fill_flags = [True]*30
-	for i, j in zip(row_idx, col_idx):
-		if j < len(unassigned): # filter out dummy channels
-			tpl_channel = tpl_order[i]
-			in_channel = unassigned[j]
-			
-			new_idx[i] = [in_dict[in_channel]["index"]]
-			fill_flags[i] = False
-			tpl_dict[tpl_channel]["matched"] = True
-			in_dict[in_channel]["assigned"] = True
-			#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)
-	
-	mapping_data = {
-		"newOrder" : new_idx,
-		"fillFlags" : fill_flags
-	}
-	channel_info.update({
-	    "templateDict" : tpl_dict,
-	    "inputDict" : in_dict
-	})
-	return mapping_data, channel_info
-
-def mapping_result(stage1_info, stage2_info, channel_info, filename):
-	unassigned_num = len(stage1_info["unassignedInputs"])
-	batch_num = math.ceil(unassigned_num/30) + 1
-	
-	# map the remaining in_channels
-	for i in range(1, batch_num):
-		# optimally select 30 in_channels to map to the tpl_channels based on proximity
-		new_mapping_data, channel_info = optimal_mapping(channel_info)
-		stage1_info["mappingData"] += [new_mapping_data]
-	
-	# save the mapping results
-	new_dict = {
-		#"templateOrder" : channel_info["templateOrder"],
-		#"inputOrder" : channel_info["inputOrder"],
-		"batchNum" : batch_num,
-		"mappingData" : stage1_info["mappingData"]
-	}
-	with open(filename, 'w') as jsonfile:
-		jsonfile.write(json.dumps(new_dict))
-		
-	stage2_info["totalBatchNum"] = batch_num
-	return stage1_info, stage2_info, channel_info
-
+import utils
+import os
+import math
+import json
+import numpy as np
+import matplotlib.pyplot as plt
+import mne
+from mne.channels import read_custom_montage
+from scipy.interpolate import Rbf
+from scipy.optimize import linear_sum_assignment
+from sklearn.neighbors import NearestNeighbors
+
+def reorder_data(idx_order, fill_flags, filename, new_filename):
+	# read the input data
+	raw_data = utils.read_train_data(filename)
+	#print(raw_data.shape)
+	new_data = np.zeros((30, raw_data.shape[1]))
+	
+	zero_arr = np.zeros((1, raw_data.shape[1]))
+	for i, (idx_set, flag) in enumerate(zip(idx_order, fill_flags)):
+		if flag == False:
+			new_data[i, :] = raw_data[idx_set[0], :]
+		elif idx_set == []:
+			new_data[i, :] = zero_arr
+		else:
+			tmp_data = [raw_data[j, :] for j in idx_set]
+			new_data[i, :] = np.mean(tmp_data, axis=0)
+	
+	utils.save_data(new_data, new_filename)
+	return raw_data.shape
+
+def restore_order(batch_cnt, raw_data_shape, idx_order, fill_flags, filename, new_filename):
+	# read the denoised data
+	d_data = utils.read_train_data(filename)
+	if batch_cnt == 0:
+		new_data = np.zeros((raw_data_shape[0], d_data.shape[1]))
+		#print(new_data.shape)
+	else:
+		new_data = utils.read_train_data(new_filename)
+	
+	for i, (idx_set, flag) in enumerate(zip(idx_order, fill_flags)):
+		# ignore if this channel was filled using "fillmode"
+		if flag == False:
+			new_data[idx_set[0], :] = d_data[i, :]
+	
+	utils.save_data(new_data, new_filename)
+	return
+
+def get_matched(tpl_order, tpl_dict):
+    return [channel for channel in tpl_order if tpl_dict[channel]["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_unassigned_inputs(in_order, in_dict):
+    return [channel for channel in in_order if in_dict[channel]["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_dict = {}
+	in_dict = {}
+	
+	# convert all channel names to uppercase and store the channel information
+	for i, channel in enumerate(tpl_order):
+		up_channel = str.upper(channel)
+		tpl_montage.rename_channels({channel: up_channel})
+		tpl_dict[up_channel] = {
+			"index" : i,
+			"coord_3d" : tpl_montage.get_positions()['ch_pos'][up_channel],
+			"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] = {
+			"index" : i,
+			"coord_3d" : in_montage.get_positions()['ch_pos'][up_channel],
+			"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_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_coords = np.vstack((tpl_x, tpl_y)).T
+	in_coords = np.vstack((in_x, in_y)).T
+	
+	# extract template's head figure
+	tpl_fig = tpl_montage.plot()
+	tpl_ax = tpl_fig.axes[0]
+	lines = tpl_ax.lines
+	head_lines = []
+	for line in lines:
+		x, y = line.get_data()
+		head_lines.append((x,y))
+	plt.close()
+	
+	# -------------------------plot input montage------------------------------
+	fig = plt.figure(figsize=(6.4,6.4), dpi=100)
+	ax = fig.add_subplot(111)
+	fig.tight_layout()
+	ax.set_aspect('equal')
+	ax.axis('off')
+	
+	# plot template's head
+	for x, y in head_lines:
+		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')
+	# 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]
+	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')
+	# save mapped_montage
+	fig.savefig(filename2)
+	
+	# -------------------------------------------------------------------------
+	# store the tpl and in_channels' display positions (in px).
+	tpl_coords = ax.transData.transform(tpl_coords)
+	in_coords = ax.transData.transform(in_coords)
+	plt.close()
+	
+	for i, channel in enumerate(tpl_order):
+		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):
+		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))+"%"]
+	
+	channel_info.update({
+		"templateDict" : tpl_dict,
+		"inputDict" : in_dict
+	})
+	return channel_info
+
+def align_coords(channel_info, tpl_montage, in_montage):
+	tpl_order = channel_info["templateOrder"]
+	in_order = channel_info["inputOrder"]
+	tpl_dict = channel_info["templateDict"]
+	in_dict = channel_info["inputDict"]
+	matched = get_matched(tpl_order, tpl_dict)
+	
+	# 2D alignment (for visualization purposes)
+	fig = [tpl_montage.plot(), in_montage.plot()]
+	ax = [fig[0].axes[0], fig[1].axes[0]]
+	
+	# extract the displayed 2D coordinates from the plots
+	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])
+	
+	# apply TPS to transform in_channels positions to align with tpl_channels positions
+	rbf_x = Rbf(matched_in[:,0], matched_in[:,1], matched_tpl[:,0], function='thin_plate')
+	rbf_y = Rbf(matched_in[:,0], matched_in[:,1], matched_tpl[:,1], function='thin_plate')
+	
+	# apply the transformation to all in_channels
+	transformed_in_x = rbf_x(all_in[:,0], all_in[:,1])
+	transformed_in_y = rbf_y(all_in[:,0], all_in[:,1])
+	transformed_in = np.vstack((transformed_in_x, transformed_in_y)).T
+	
+	# store the 2D positions
+	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()
+	
+	
+	# 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])
+	
+	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')
+	rbf_z = Rbf(matched_in[:,0], matched_in[:,1], matched_in[:,2], matched_tpl[:,2], function='thin_plate')
+	
+	transformed_in_x = rbf_x(all_in[:,0], all_in[:,1], all_in[:,2])
+	transformed_in_y = rbf_y(all_in[:,0], all_in[:,1], all_in[:,2])
+	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
+	
+	# update in_channels' 3D positions
+	for i, channel in enumerate(in_order):
+		in_dict[channel]["coord_3d"] = transformed_in[i].tolist()
+	
+	channel_info.update({
+	    "templateDict" : tpl_dict,
+	    "inputDict" : in_dict
+	})
+	return channel_info
+
+def find_neighbors(channel_info, missing_channels, 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]
+	
+	# 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):
+		distances, indices = knn.kneighbors(empty_tpl[i].reshape(1,-1))
+		idx = tpl_dict[channel]["index"]
+		new_idx[idx] = indices[0].tolist()
+    
+	return new_idx
+
+def match_names(stage1_info, channel_info):
+    # read the location file
+	loc_file = stage1_info["fileNames"]["input_loc"]
+	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
+	new_idx = [[]]*30 # store the indices of the in_channels in the order of tpl_channels
+	fill_flags = [True]*30 # record if each tpl_channel's data is filled by "fillmode"
+	
+	alias_dict = {
+		'T3': 'T7',
+		'T4': 'T8',
+		'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]
+			
+		if channel in in_dict:
+			new_idx[i] = [in_dict[channel]["index"]]
+			fill_flags[i] = False
+			tpl_dict[channel]["matched"] = True
+			in_dict[channel]["assigned"] = True
+	
+	# update the names
+	tpl_order = tpl_montage.ch_names
+	
+	stage1_info.update({
+	    "unassignedInputs" : get_unassigned_inputs(in_order, in_dict),
+	    "missingTemplates" : get_empty_templates(tpl_order, tpl_dict),
+	    "mappingData" : [
+		{
+			"newOrder" : new_idx,
+			"fillFlags" : fill_flags
+		}
+	    ]
+	})
+	channel_info.update({
+		"templateOrder" : tpl_order,
+		"inputOrder" : in_order,
+	    "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_dict = channel_info["templateDict"]
+	in_dict = channel_info["inputDict"]
+	unassigned = 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])
+	
+	# initialize the cost matrix for the Hungarian algorithm
+	if len(unassigned) < 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)))
+	# fill the cost matrix with Euclidean distances between tpl_channels 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)
+	
+	# apply the Hungarian algorithm to optimally assign one in_channel to each tpl_channel
+	# by minimizing the total distances between their positions.
+	row_idx, col_idx = linear_sum_assignment(cost_matrix)
+	
+	# store the mapping results
+	new_idx = [[]]*30
+	fill_flags = [True]*30
+	for i, j in zip(row_idx, col_idx):
+		if j < len(unassigned): # filter out dummy channels
+			tpl_channel = tpl_order[i]
+			in_channel = unassigned[j]
+			
+			new_idx[i] = [in_dict[in_channel]["index"]]
+			fill_flags[i] = False
+			tpl_dict[tpl_channel]["matched"] = True
+			in_dict[in_channel]["assigned"] = True
+			#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)
+	
+	mapping_data = {
+		"newOrder" : new_idx,
+		"fillFlags" : fill_flags
+	}
+	channel_info.update({
+	    "templateDict" : tpl_dict,
+	    "inputDict" : in_dict
+	})
+	return mapping_data, channel_info
+
+def mapping_result(stage1_info, stage2_info, channel_info, filename):
+	unassigned_num = len(stage1_info["unassignedInputs"])
+	batch_num = math.ceil(unassigned_num/30) + 1
+	
+	# map the remaining in_channels
+	for i in range(1, batch_num):
+		# optimally select 30 in_channels to map to the tpl_channels based on proximity
+		new_mapping_data, channel_info = optimal_mapping(channel_info)
+		stage1_info["mappingData"] += [new_mapping_data]
+	
+	# save the mapping results
+	new_dict = {
+		#"templateOrder" : channel_info["templateOrder"],
+		#"inputOrder" : channel_info["inputOrder"],
+		"batchNum" : batch_num,
+		"mappingData" : stage1_info["mappingData"]
+	}
+	with open(filename, 'w') as jsonfile:
+		jsonfile.write(json.dumps(new_dict))
+		
+	stage2_info["totalBatchNum"] = batch_num
+	return stage1_info, stage2_info, channel_info
+

utils.py

@@ -143,7 +143,8 @@ def dataDelete(path):
     try:
         shutil.rmtree(path)
     except OSError as e:
-        print(e)
+        pass
+        #print(e)
     else:
         pass
         #print("The directory is deleted successfully")