update

app.py

@@ -22,14 +22,14 @@ The following steps will guide you through the process of mapping your EEG chann
 
 ### Step1: Initial Matching and Scaling
 After clicking on ``Map`` button, we will first match your channels to our template channels by their names. Using the matched channels as reference points, we will apply Thin Plate Spline (TPS) transformation to scale your montage to align with our template's dimensions. The template montage and your scaled montage will be displayed side by side for comparison. Channels that do not have a match in our template will be **highlighted in red**.
-- If your data includes all the 30 template channels, you will be directed to **Mapping Results**.
+- If your data includes all the 30 template channels, you will be directed to **Mapping Result**.
 - If your data doesn't include all the 30 template channels and you have some channels that do not match the template, you will be directed to **Step2**.
 - If all your channels are included in our template but you have fewer than 30 channels, you will be directed to **Step3**.
 
 ### Step2: Forwarding Unmatched Channels
 In this step, you will handle the channels that didn't have a direct match with our template, by manually assigning them to the template channels that are still empty, ensuring the most efficient use of your data.  
 Your unmatched channels, previously highlighted in red, will be shown on your montage with a radio button displayed above each. You can choose to forward the data from these unmatched channels to the empty template channels. The interface will display each empty template channel in sequence, allowing you to select which of your unmatched channels to forward.
-- If all empty template channels are filled by your selections, you will be directed to **Mapping Results**.
+- If all empty template channels are filled by your selections, you will be directed to **Mapping Result**.
 - If there are still empty template channels remaining, you will be directed to **Step3**.
 
 ### Step3: Filling Remaining Template Channels
@@ -37,15 +37,15 @@ To run the models successfully, we need to ensure that all 30 template channels
 - **Mean** method: Each empty template channel is filled with the average value of data from the nearest input channels. By default, the 4 closest input channels (determined after aligning your montage to the template's scale using TPS) are selected for this averaging process. On the interface, you will see checkboxes displayed above each of your channel. The 4 nearest channels are pre-selected by default for each empty template channels, but you can modify these selections as needed. If you uncheck all the checkboxes for a particular template channel, it will be filled with zeros.
 - **Zero** method: All empty template channels are filled with zeros.  
 Choose the method that best suits your needs, considering that the model's performance may vary depending on the method used.  
-Once all template channels are filled, you will be directed to **Mapping Results**.
+Once all template channels are filled, you will be directed to **Mapping Result**.
 
-### Mapping Results
+### Mapping Result
 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.
+- 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 result.
+- Once the mapping process is completed, a JSON file containing the mapping result 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 divided 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 result. 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 = """
@@ -75,8 +75,6 @@ init_js = """
 		position: relative;
 		width: 100%;
 		aspect-ratio: 1;
-		//width: 560px;
-		//height: 560px;
 		background: url("file=${stage1_info.fileNames.inputMontage}");
 		background-size: contain;
 	`;
@@ -213,8 +211,8 @@ update_js = """
 
 with gr.Blocks() as demo:
 	stage1_json = gr.JSON({}, visible=False)
-	stage2_json = gr.JSON(visible=False)
-	channel_json = gr.JSON(visible=False)
+	stage2_json = gr.JSON({}, visible=False)
+	channel_json = gr.JSON({}, visible=False)
 
 	gr.Markdown(intro)
 	with gr.Row():
@@ -232,7 +230,7 @@ with gr.Blocks() as demo:
 			# step1
 			with gr.Row():
 				tpl_img = gr.Image("./template_montage.png", label="Template montage", visible=False)
-				mapped_img = gr.Image(label="Matching results", visible=False)
+				mapped_img = gr.Image(label="Matching result", visible=False)
 			# step2
 			radio_group = gr.Radio(elem_id="radio-group", visible=False)
 			# step3
@@ -295,7 +293,7 @@ with gr.Blocks() as demo:
 			return {stage1_json : stage1_info}
 	    
 		# stop Stage2
-		if stage2_info!=None and stage2_info["state"]=="running":
+		if "state" in stage2_info and stage2_info["state"]=="running":
 			utils.dataDelete(stage2_info["filePath"])
 		
 		rootpath = os.path.dirname(str(in_loc))
@@ -331,7 +329,7 @@ with gr.Blocks() as demo:
 	    	"unassignedInputs" : None,
 	    	"emptyTemplates" : None,
 	    	"batchNum" : None,
-	    	"mappingResults" : [
+	    	"mappingResult" : [
 	    	{
 				"newOrder" : None,
 				"isOriginalData" : None
@@ -339,25 +337,25 @@ with gr.Blocks() as demo:
 			}
 	    	]
 		}
-		stage2_info = None
-		channel_info = None
+		stage2_info = {}
+		channel_info = {}
 		return {stage1_json : stage1_info,
 				stage2_json : stage2_info,
 				channel_json : channel_info,
 				# --------------------Stage1-------------------------
 				map_btn : gr.Button(interactive=False),
-				desc_md : gr.Markdown("", visible=False),
-				next_btn : gr.Button(visible=False),
+				desc_md : gr.Markdown("", visible=True),
+				out_result_file : gr.File(value=None, visible=False),
 				tpl_img : gr.Image(visible=False),
 				mapped_img : gr.Image(value=None, visible=False),
 				radio_group : gr.Radio(choices=[], value=[], label="", visible=False),
-				clear_btn : gr.Button(visible=False),
-				step2_btn : gr.Button(visible=False),
 				in_fillmode : gr.Dropdown(value="mean", visible=False),
 				fillmode_btn : gr.Button(visible=False),
 				chkbox_group : gr.CheckboxGroup(choices=[], value=[], label='', visible=False),
+				clear_btn : gr.Button(visible=False),
+				step2_btn : gr.Button(visible=False),
 				step3_btn : gr.Button(visible=False),
-				out_result_file : gr.File(value=None, visible=False),
+				next_btn : gr.Button(visible=False),
 				# --------------------Stage2-------------------------
 				in_data_file : gr.File(value=None),
 				in_samplerate : gr.Textbox(value=None),
@@ -373,13 +371,11 @@ with gr.Blocks() as demo:
 	def init_next_step(stage1_info, channel_info, fillmode, sel_radio, sel_chkbox):
 		if stage1_info["errorFlag"] == True:
 			stage1_info["errorFlag"] = False
-			yield {stage1_json : stage1_info}
+			return {stage1_json : stage1_info}
 		
 		# ========================================step0=========================================
 		# step0 to step1
-		elif stage1_info["state"] == "step1-initializing":
-			yield {desc_md : gr.Markdown("Mapping...", visible=True)}
-		    
+		if stage1_info["state"] == "step1-initializing":
 			# match the names
 			stage1_info, channel_info, tpl_montage, in_montage = app_utils.match_names(stage1_info)
 			# scale the coordinates
@@ -402,7 +398,7 @@ with gr.Blocks() as demo:
 				- channels highlighted in red are those that do not match any template channels.
 				"""
 			stage1_info["state"] = "step1-finished"
-			yield {stage1_json : stage1_info,
+			return {stage1_json : stage1_info,
 					channel_json : channel_info,
 					map_btn : gr.Button(interactive=True),
 					desc_md : gr.Markdown(md),
@@ -418,22 +414,23 @@ with gr.Blocks() as demo:
 			# step1 to step4
 			if matched_num == 30:
 				md = """
-				### Mapping Results
+				### Mapping Result
 				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
+				# finalize and save the mapping result
 				outputname = stage1_info["fileNames"]["outputResult"]
 				stage1_info, channel_info = app_utils.mapping_result(stage1_info, channel_info, outputname)
 				
 				stage1_info["state"] = "finished"
-				yield {stage1_json : stage1_info,
+				return {stage1_json : stage1_info,
 						channel_json : channel_info,
 						desc_md : gr.Markdown(md),
+						out_result_file : gr.File(outputname, visible=True),
 						tpl_img : gr.Image(visible=False),
 						mapped_img : gr.Image(visible=False),
 						next_btn : gr.Button(visible=False),
-						out_result_file : gr.File(outputname, visible=True)}
+						run_btn : gr.Button(interactive=True)}
 			# step1 to step2
 			elif in_num > matched_num: 
 				md = """
@@ -452,14 +449,14 @@ with gr.Blocks() as demo:
 				stage1_info["state"] = "step2-selecting"
 				# determine which button to display
 				if stage1_info["step2"]["totalNum"] == 1:
-					yield {stage1_json : stage1_info,
+					return {stage1_json : stage1_info,
 							desc_md : gr.Markdown(md),
 							tpl_img : gr.Image(visible=False),
 							mapped_img : gr.Image(visible=False),
 							radio_group : gr.Radio(choices=stage1_info["unassignedInputs"], value=[], label=label, visible=True),
 							clear_btn : gr.Button(visible=True)}
 				else:
-					yield {stage1_json : stage1_info,
+					return {stage1_json : stage1_info,
 							desc_md : gr.Markdown(md),
 							tpl_img : gr.Image(visible=False),
 							mapped_img : gr.Image(visible=False),
@@ -474,7 +471,7 @@ with gr.Blocks() as demo:
 				Select one of the methods provided below to fill the remaining template channels.
 				"""
 				stage1_info["state"] = "step3-select-method"
-				yield {stage1_json : stage1_info,
+				return {stage1_json : stage1_info,
 						desc_md : gr.Markdown(md),
 						tpl_img : gr.Image(visible=False),
 						mapped_img : gr.Image(visible=False),
@@ -491,8 +488,8 @@ 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["mappingResults"][0]["newOrder"][prev_tpl_idx] = [sel_idx]
-				stage1_info["mappingResults"][0]["isOriginalData"][prev_tpl_idx] = True
+				stage1_info["mappingResult"][0]["newOrder"][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
 				#print(prev_tpl_name, '<-', sel_radio)
@@ -508,7 +505,7 @@ with gr.Blocks() as demo:
 			# step2 to step4
 			if len(stage1_info["emptyTemplates"]) == 0:
 				md = """
-				### Mapping Results
+				### Mapping Result
 				The mapping process has been finished.  
 				Download the file below if you plan to run the models using the <a href="">source code</a>.
 				"""
@@ -516,13 +513,14 @@ with gr.Blocks() as demo:
 				stage1_info, channel_info = app_utils.mapping_result(stage1_info, channel_info, outputname)
 				
 				stage1_info["state"] = "finished"
-				yield {stage1_json : stage1_info,
+				return {stage1_json : stage1_info,
 						channel_json : channel_info,
 						desc_md : gr.Markdown(md),
-						radio_group : gr.Radio(visible=False),
 						out_result_file : gr.File(outputname, visible=True),
+						radio_group : gr.Radio(visible=False),
 						clear_btn : gr.Button(visible=False),
-						next_btn : gr.Button(visible=False)}
+						next_btn : gr.Button(visible=False),
+						run_btn : gr.Button(interactive=True)}
 			# step2 to step3-1
 			else:
 				md = """
@@ -530,7 +528,7 @@ with gr.Blocks() as demo:
 				Select one of the methods provided below to fill the remaining template channels.
 				"""
 				stage1_info["state"] = "step3-select-method"
-				yield {stage1_json : stage1_info,
+				return {stage1_json : stage1_info,
 						channel_json : channel_info,
 						desc_md : gr.Markdown(md),
 						radio_group : gr.Radio(visible=False),
@@ -544,7 +542,7 @@ with gr.Blocks() as demo:
 			# step3-1 to step4
 			if fillmode == "zero":
 				md = """
-				### Mapping Results
+				### Mapping Result
 				The mapping process has been finished.  
 				Download the file below if you plan to run the models using the <a href="">source code</a>.
 				"""
@@ -552,12 +550,13 @@ with gr.Blocks() as demo:
 				stage1_info, channel_info = app_utils.mapping_result(stage1_info, channel_info, outputname)
 				
 				stage1_info["state"] = "finished"
-				yield {stage1_json : stage1_info,
+				return {stage1_json : stage1_info,
 						channel_json : channel_info,
 						desc_md : gr.Markdown(md),
+						out_result_file : gr.File(outputname, visible=True),
 						in_fillmode : gr.Dropdown(visible=False),
 						fillmode_btn : gr.Button(visible=False),
-						out_result_file : gr.File(outputname, visible=True)}
+						run_btn : gr.Button(interactive=True)}
 			# step3-1 to step3-2
 			elif fillmode == "mean":
 				md = """
@@ -566,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["mappingResults"][0]["newOrder"] = app_utils.find_neighbors(
+				stage1_info["mappingResult"][0]["newOrder"] = app_utils.find_neighbors(
 																		channel_info,
 																		stage1_info["emptyTemplates"],
-																		stage1_info["mappingResults"][0]["newOrder"])
+																		stage1_info["mappingResult"][0]["newOrder"])
 				# initialize the progress indication label
 				stage1_info["step3"] = {
 					"count" : 1,
@@ -579,13 +578,13 @@ 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["mappingResults"][0]["newOrder"][tpl_idx]
+				value = stage1_info["mappingResult"][0]["newOrder"][tpl_idx]
 				value = [channel_info["inputNames"][i] for i in value]
 				
 				stage1_info["state"] = "step3-2-selecting"
 				# determine which button to display
 				if stage1_info["step3"]["totalNum"] == 1:
-					yield {stage1_json : stage1_info,
+					return {stage1_json : stage1_info,
 					        desc_md : gr.Markdown(md),
 							in_fillmode : gr.Dropdown(visible=False),
 				    		fillmode_btn : gr.Button(visible=False),
@@ -593,7 +592,7 @@ with gr.Blocks() as demo:
 															value=value, label=label, visible=True),
 				            next_btn : gr.Button(visible=True)}
 				else:
-					yield {stage1_json : stage1_info,
+					return {stage1_json : stage1_info,
 					        desc_md : gr.Markdown(md),
 							in_fillmode : gr.Dropdown(visible=False),
 				    		fillmode_btn : gr.Button(visible=False),
@@ -608,11 +607,11 @@ 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["mappingResults"][0]["newOrder"][prev_tpl_idx] = sel_idx if sel_idx!=[] else [None]
+			stage1_info["mappingResult"][0]["newOrder"][prev_tpl_idx] = sel_idx if sel_idx!=[] else [None]
 			#print(prev_tpl_name, '<-', sel_chkbox)
 			# ----------------------------------------------------------------------------------
 			md = """
-			### Mapping Results
+			### Mapping Result
 			The mapping process has been finished.  
 			Download the file below if you plan to run the models using the <a href="">source code</a>.
 			"""
@@ -620,18 +619,19 @@ with gr.Blocks() as demo:
 			stage1_info, channel_info = app_utils.mapping_result(stage1_info, channel_info, outputname)
 			
 			stage1_info["state"] = "finished"
-			yield {stage1_json : stage1_info,
+			return {stage1_json : stage1_info,
 					channel_json : channel_info,
 					desc_md : gr.Markdown(md),
+					out_result_file : gr.File(outputname, visible=True),
 					chkbox_group : gr.CheckboxGroup(visible=False),
 					next_btn : gr.Button(visible=False),
-					out_result_file : gr.File(outputname, visible=True)}
+					run_btn : gr.Button(interactive=True)}
 	
 	next_btn.click(
 		fn = init_next_step,
 		inputs = [stage1_json, channel_json, in_fillmode, radio_group, chkbox_group],
-		outputs = [stage1_json, channel_json, desc_md, tpl_img, mapped_img, radio_group, clear_btn, step2_btn,
-		            in_fillmode, fillmode_btn, chkbox_group, step3_btn, out_result_file, next_btn]
+		outputs = [stage1_json, channel_json, desc_md, out_result_file, tpl_img, mapped_img, radio_group,
+		            in_fillmode, fillmode_btn, chkbox_group, clear_btn, step2_btn, step3_btn, next_btn, run_btn]
 	).success(
 	    fn = None,
 	    js = init_js,
@@ -646,9 +646,9 @@ with gr.Blocks() as demo:
 	map_btn.click(
 	    fn = reset_all,
 	    inputs = [stage1_json, stage2_json, in_loc_file],
-	    outputs = [stage1_json, stage2_json, channel_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_result_file, in_data_file, in_samplerate, run_btn, cancel_btn, batch_md, out_data_file]
+	    outputs = [stage1_json, stage2_json, channel_json, map_btn, desc_md, out_result_file, tpl_img, mapped_img,
+	    			radio_group, in_fillmode, fillmode_btn, chkbox_group, clear_btn, step2_btn, step3_btn, next_btn,
+	    			in_data_file, in_samplerate, run_btn, cancel_btn, batch_md, out_data_file]
 	).success(
 	    fn = init_next_step,
 	    inputs = [stage1_json, channel_json, in_fillmode, radio_group, chkbox_group], 
@@ -686,8 +686,8 @@ 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["mappingResults"][0]["newOrder"][prev_tpl_idx] = [sel_idx]
-			stage1_info["mappingResults"][0]["isOriginalData"][prev_tpl_idx] = True
+			stage1_info["mappingResult"][0]["newOrder"][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
 			#print(prev_tpl_name, '<-', sel_name)
@@ -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["mappingResults"][0]["newOrder"][prev_tpl_idx] = sel_idx if sel_idx!=[] else [None]
+		stage1_info["mappingResult"][0]["newOrder"][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["mappingResults"][0]["newOrder"][tpl_idx]
+		value = stage1_info["mappingResult"][0]["newOrder"][tpl_idx]
 		value = [channel_info["inputNames"][i] for i in value]
 		
 		stage1_info["step3"] = step3
@@ -763,8 +763,8 @@ with gr.Blocks() as demo:
 	fillmode_btn.click(
 	    fn = init_next_step,
 		inputs = [stage1_json, channel_json, in_fillmode, radio_group, chkbox_group],
-		outputs = [stage1_json, channel_json, desc_md, in_fillmode, fillmode_btn, chkbox_group, step3_btn,
-					out_result_file, next_btn]
+		outputs = [stage1_json, channel_json, desc_md, out_result_file, in_fillmode, fillmode_btn,
+		            chkbox_group, step3_btn, next_btn, run_btn]
 	).success(
 	    fn = None,
 	    js = init_js,
@@ -786,22 +786,19 @@ with gr.Blocks() as demo:
 	
 	# +========================================================================================+
 	# |                                  Stage2: decode data                                   |
-	# +========================================================================================+
-	@gr.on(triggers = [in_data_file.upload, in_data_file.clear, in_samplerate.input, out_result_file.change],
-			inputs = [stage1_json, in_data_file, in_samplerate], outputs = run_btn)
-	def check_input(stage1_info, in_data, samplerate):
-		if stage1_info["state"]=="finished" and in_data!=None and samplerate!="":
-			return gr.Button(interactive=True)
-		else:
-			return gr.Button(interactive=False)
-	
+	# +========================================================================================+	
 	@cancel_btn.click(inputs = stage2_json, outputs = [stage2_json, cancel_btn, batch_md])
 	def stop_stage2(stage2_info):
 		utils.dataDelete(stage2_info["filePath"])
 		stage2_info["state"] = "stopped"
 		return stage2_info, gr.Button(interactive=False), gr.Markdown(visible=False)
 	
-	def reset_stage2(in_data, samplerate, modelname):
+	def reset_stage2(stage2_info, in_data, samplerate, modelname):
+		if in_data==None or samplerate=="":
+			gr.Warning("Please upload a file and enter the sampling rate.")
+			stage2_info["errorFlag"] = True
+			return {stage2_json : stage2_info}
+	    
 		rootpath =  os.path.dirname(str(in_data))
 		# delete the previous folder(s) of Stage2
 		folders = [ f.path for f in os.scandir(rootpath) if f.is_dir()]
@@ -821,7 +818,7 @@ with gr.Blocks() as demo:
 				"outputData" : rootpath+'/'+stage2_id+'/'+outputname
 			},
 			"state" : "running",
-			"sampleRate" : int(samplerate)
+			"errorFlag" : False
 		}
 		return {stage2_json : stage2_info,
 				run_btn : gr.Button(visible=False),
@@ -829,61 +826,51 @@ with gr.Blocks() as demo:
 				batch_md : gr.Markdown("", visible=True),
 				out_data_file : gr.File(value=None, visible=False)}
 	
-	def run_model(stage1_info, stage2_info, modelname):
-		batch_num = stage1_info["batchNum"]
-		mapping_results = stage1_info["mappingResults"]
-		samplerate = stage2_info["sampleRate"]
-		filepath = stage2_info["filePath"]
-		inputname = stage2_info["fileNames"]["inputData"]
-		outputname = stage2_info["fileNames"]["outputData"]
+	def run_stage2(stage1_info, stage2_info, samplerate, modelname):
+		if stage2_info["errorFlag"] == True:
+			stage2_info["errorFlag"] = False
+			yield {stage2_json : stage2_info}
 		
-		out_basename = os.path.basename(str(outputname))
-		out_basename = os.path.splitext(out_basename)[0]
-		break_flag = False
-		for i in range(batch_num):
-			yield {batch_md : gr.Markdown('Running model({}/{})...'.format(i+1, batch_num))}
+		else:
+			inputname = stage2_info["fileNames"]["inputData"]
+			outputname = stage2_info["fileNames"]["outputData"]
+			out_basename = os.path.basename(str(outputname))
+			out_basename = os.path.splitext(out_basename)[0]
 			
-			new_idx = mapping_results[i]["newOrder"]
-			orig_flags = mapping_results[i]["isOriginalData"]
-			m_filename = 'mapped_{:02d}.csv'.format(i+1)
-			d_filename = '{}_{:02d}.csv'.format(out_basename, i+1)
-			try:
-				# establish a temp folder
-				os.mkdir(filepath+'temp_data/')
+			for i in range(stage1_info["batchNum"]):
+				yield {batch_md : gr.Markdown('Running model({}/{})...'.format(i+1, stage1_info["batchNum"]))}
 				
-				# step1: Reorder input data
-				data_shape = app_utils.reorder_data(new_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
-				app_utils.restore_order(i, data_shape, new_idx, orig_flags, filepath+'temp_data/'+d_filename, outputname)
-			except FileNotFoundError:
-				print('break!!')
-				break_flag = True
-				break
+				break_flag = app_utils.run_model(modelname = modelname,
+												filepath = stage2_info["filePath"],
+												inputname = inputname,
+												m_filename = 'mapped_{:02d}.csv'.format(i+1),
+												d_filename = '{}_{:02d}.csv'.format(out_basename, i+1),
+												outputname = outputname,
+												samplerate = int(samplerate),
+												batch_cnt = i,
+												new_idx = stage1_info["mappingResult"][i]["newOrder"],
+												orig_flags = stage1_info["mappingResult"][i]["isOriginalData"])
+				if break_flag == True:
+					break
+			
+			if break_flag == True:
+				yield {run_btn : gr.Button(visible=True),
+						cancel_btn : gr.Button(visible=False)}
 			else:
-				utils.dataDelete(filepath+'temp_data/')
-		
-		if break_flag == True:
-			yield {run_btn : gr.Button(visible=True),
-					cancel_btn : gr.Button(visible=False)}
-		else:
-			stage2_info["state"] = "finished"
-			yield {stage2_json : stage2_info,
-					run_btn : gr.Button(visible=True),
-					cancel_btn : gr.Button(visible=False),
-					batch_md : gr.Markdown(visible=False),
-					out_data_file : gr.File(outputname, visible=True)}
+				stage2_info["state"] = "finished"
+				yield {stage2_json : stage2_info,
+						run_btn : gr.Button(visible=True),
+						cancel_btn : gr.Button(visible=False),
+						batch_md : gr.Markdown(visible=False),
+						out_data_file : gr.File(outputname, visible=True)}
 	
 	run_btn.click(
 		fn = reset_stage2,
-		inputs = [in_data_file, in_samplerate, in_modelname],
+		inputs = [stage2_json, in_data_file, in_samplerate, in_modelname],
 		outputs = [stage2_json, run_btn, cancel_btn, batch_md, out_data_file]
 	).success(
-		fn = run_model,
-		inputs = [stage1_json, stage2_json, in_modelname],
+		fn = run_stage2,
+		inputs = [stage1_json, stage2_json, in_samplerate, in_modelname],
 		outputs = [stage2_json, run_btn, cancel_btn, batch_md, out_data_file]
 	)
 	

app_utils.py

@@ -11,41 +11,6 @@ from scipy.interpolate import Rbf
 from scipy.optimize import linear_sum_assignment
 from sklearn.neighbors import NearestNeighbors
 
-def reorder_data(idx_order, 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, (idx_set, flag) in enumerate(zip(idx_order, orig_flags)):
-		if flag == True:
-			new_data[i, :] = raw_data[idx_set[0], :]
-		elif idx_set == [None]:
-			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, filename)
-	return raw_data.shape
-
-def restore_order(batch_cnt, raw_data_shape, idx_order, orig_flags, filename, outputname):
-	# 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(outputname)
-	
-	for i, (idx_set, flag) in enumerate(zip(idx_order, orig_flags)):
-		if flag == True:
-			new_data[idx_set[0], :] = d_data[i, :]
-	
-	utils.save_data(new_data, outputname)
-	return
-
 def get_matched(tpl_names, tpl_dict):
     return [name for name in tpl_names if tpl_dict[name]["matched"]==True]
 
@@ -261,7 +226,7 @@ def match_names(stage1_info):
 	stage1_info.update({
 	    "unassignedInputs" : get_unassigned_inputs(in_names, in_dict),
 	    "emptyTemplates" : get_empty_templates(tpl_names, tpl_dict),
-	    "mappingResults" : [
+	    "mappingResult" : [
 		{
 			"newOrder" : new_idx,
 			"isOriginalData" : orig_flags
@@ -303,7 +268,7 @@ def optimal_mapping(channel_info):
 	# by minimizing the total distances between their positions.
 	row_idx, col_idx = linear_sum_assignment(cost_matrix)
 	
-	# store the mapping results
+	# store the mapping result
 	new_idx = [[None]]*30
 	orig_flags = [False]*30
 	for i, j in zip(row_idx, col_idx):
@@ -337,7 +302,7 @@ def mapping_result(stage1_info, channel_info, filename):
 	batch_num = math.ceil(unassigned_num/30) + 1
 	
 	# map the remaining in_channels
-	results = stage1_info["mappingResults"]
+	results = stage1_info["mappingResult"]
 	for i in range(1, batch_num):
 		# optimally select 30 in_channels to map to the tpl_channels based on proximity
 		result, channel_info = optimal_mapping(channel_info)
@@ -347,17 +312,78 @@ def mapping_result(stage1_info, channel_info, filename):
 		#"templateNames" : channel_info["templateNames"],
 		#"inputNames" : channel_info["inputNames"],
 		"batchNum" : batch_num,
-		"mappingResults" : results
+		"mappingResult" : results
 	}
 	options = jsbeautifier.default_options()
 	options.indent_size = 4
-	res = jsbeautifier.beautify(json.dumps(data), options)
+	json_data = jsbeautifier.beautify(json.dumps(data), options)
 	with open(filename, 'w') as jsonfile:
-		jsonfile.write(res)
+		jsonfile.write(json_data)
 	
 	stage1_info.update({
 		"batchNum" : batch_num,
-		"mappingResults" : results
+		"mappingResult" : results
 	})
 	return stage1_info, channel_info
 
+
+def reorder_data(idx_order, 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, (idx_set, flag) in enumerate(zip(idx_order, orig_flags)):
+		if flag == True:
+			new_data[i, :] = raw_data[idx_set[0], :]
+		elif idx_set == [None]:
+			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, filename)
+	return raw_data.shape
+
+def restore_order(batch_cnt, raw_data_shape, idx_order, orig_flags, filename, outputname):
+	# 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(outputname)
+	
+	for i, (idx_set, flag) in enumerate(zip(idx_order, orig_flags)):
+		if flag == True:
+			new_data[idx_set[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):
+	try:
+		# establish a 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)
+		# 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)
+		
+	except FileNotFoundError:
+		print('stop!!')
+		stop_flag = True
+		
+	else:
+		utils.dataDelete(filepath+'temp_data/')
+		stop_flag = False
+		
+	finally:
+		return stop_flag
+