update v3

app.py

@@ -4,7 +4,7 @@ import os
 import random
 import math
 import utils
-from channel_mapping import mapping_stage1, mapping_stage2, reorder_to_template, reorder_to_origin
+from channel_mapping import mapping_stage1, mapping_stage2, reorder_to_template, reorder_to_origin, find_neighbors
 
 import mne
 from mne.channels import read_custom_montage
@@ -60,8 +60,7 @@ chkbox_js = """
 	
 	
 	// add indication for the missing channels
-	let channel = channel_info.missingChannelsIndex[0]
-	channel = channel_info.templateByIndex[channel]
+	let channel = channel_info.missingChannels[0]
 	let left = channel_info.templateByName[channel].css_position[0];
 	let bottom = channel_info.templateByName[channel].css_position[1];
 	
@@ -120,8 +119,7 @@ indication_js = """
 	channel_info = JSON.parse(JSON.stringify(channel_info));
 	if(app_state.state == "finished") return;
 	
-	let channel = channel_info.missingChannelsIndex[app_state["fillingCount"]-1]
-	channel = channel_info.templateByIndex[channel]
+	let channel = channel_info.missingChannels[app_state["fillingCount"]-1]
 	let left = channel_info.templateByName[channel].css_position[0];
 	let bottom = channel_info.templateByName[channel].css_position[1];
 	
@@ -169,51 +167,46 @@ with gr.Blocks() as demo:
 	with gr.Row():
 
 		with gr.Column():
-			gr.Markdown(
-				"""
-				# 1.Channel Mapping
-				"""
-			)
-
-			# upload files, chose imputation way (???
+			gr.Markdown("# 1.Channel Mapping")
+			# ------------------------input--------------------------
 			with gr.Row():
 				in_raw_data = gr.File(label="Raw data (.csv)", file_types=[".csv"])
 				in_raw_loc = gr.File(label="Channel locations (.loc, .locs)", file_types=[".loc", "locs"])
-				with gr.Column(min_width=100):
-					in_sample_rate = gr.Textbox(label="Sampling rate (Hz)")
-					in_fill_mode = gr.Dropdown(choices=[
-										#("adjacent channel", "adjacent"),
-										("mean (auto)", "mean_auto"),
-										("mean (manual)", "mean_manual"),
-										("",""),
-										"zero"],
-										value="mean_auto",
-										label="Imputation")
+				with gr.Column(): #min_width=100
+					in_samplerate = gr.Textbox(label="Sampling rate (Hz)")
 					map_btn = gr.Button("Mapping")
 			
-			chkbox_group = gr.CheckboxGroup(elem_id="chkbox-group", label="", visible=False)
-			next_btn = gr.Button("Next", interactive=False, visible=False)
+			# ------------------------mapping------------------------
+			# description for step123
+			desc_md = gr.Markdown("### Mapping result:", visible=False) # """??? # test
 			
-			# mapping result
-			res_md = gr.Markdown(
-						"""
-						### Mapping result:
-						""",
-						visible=False
-					)
+			# step1 : mapping result
 			with gr.Row():
 				tpl_montage = gr.Image("./template_montage.png", label="Template montage", visible=False)
-				map_montage = gr.Image(label="Matched channels", visible=False)
+				map_montage = gr.Image(label="Input channels", visible=False)
+			
+			# step2 : assign unmatched input channels to empty template channels
+			radio = gr.Radio(elem_id="radio", visible=False) #, label=""
+			step2_btn = gr.Button("Next", visible=False) #, interactive=False
+			
+			# step3 : select a way to fill the empty template channels
+			with gr.Row():
+				in_fill_mode = gr.Dropdown(choices=["mean", "zero"],
+									value="mean",
+									label="Imputation", #......
+									visible=False,
+									scale=2)
+				fillmode_btn = gr.Button("OK", visible=False, scale=1)
+			
+			chkbox_group = gr.CheckboxGroup(elem_id="chkbox-group", label="", visible=False)
+			step3_btn = gr.Button("Next", visible=False)
+			next_btn = gr.Button("Next step", visible=False)
 			
-			#miss_txtbox = gr.Textbox(label="Missing channels", visible=False)
-			#tpl_loc_file = gr.File("./template_chanlocs.loc", show_label=False, visible=False)
+			# -------------------------------------------------------
 
 		with gr.Column():
-			gr.Markdown(
-				"""
-				# 2.Decode Data
-				"""
-			)
+			gr.Markdown("# 2.Decode Data")
+			# ------------------------input--------------------------
 			with gr.Row():
 				in_model_name = gr.Dropdown(choices=[
 									("ART", "EEGART"),
@@ -226,9 +219,16 @@ with gr.Blocks() as demo:
 									label="Model",
 									scale=2)
 				run_btn = gr.Button(scale=1, interactive=False)
+			
+			# ------------------------output-------------------------
 			batch_md = gr.Markdown(visible=False)
 			out_denoised_data = gr.File(label="Denoised data", visible=False)
-	
+			
+			#files = []
+			#for i in range():
+				#f = gr.File()
+				#files.append(f)
+			# -------------------------------------------------------	
 				
 	with gr.Row():
 		with gr.Tab("ART"):
@@ -244,7 +244,16 @@ with gr.Blocks() as demo:
     
 	#demo.load(js=js)
 	
-	def reset1(raw_data, samplerate):
+	# click on mapping button
+	def reset_all(raw_data, raw_loc, samplerate):
+		# verify that all required inputs have been provided
+		if raw_data == None or raw_loc == None:
+			gr.Warning('Please upload both the raw data and the channel location files.')
+			return
+		if samplerate == "":
+			gr.Warning('Please enter the sampling rate.')
+			return
+	    
 		# establish temp folder
 		filepath = os.path.dirname(str(raw_data))
 		try:
@@ -255,216 +264,361 @@ with gr.Blocks() as demo:
 			#print(e)
 		
 		# initialize app_state, channel_info
-		data = utils.read_train_data(raw_data)
+		#data = utils.read_train_data(raw_data)
 		app_state = {
 			"filepath": filepath+"/temp_data/",
 			"filenames": {},
 			"sampleRate": int(samplerate),
-			
+			"state" : "step1"
 		}
 		channel_info = {
-			"dataShape" : data.shape
+			#"dataShape" : data.shape
 		}
 		
+		# reset layout
 		return {app_state_json : app_state,
 				channel_info_json : channel_info,
-				chkbox_group : gr.CheckboxGroup(choices=[], value=[], label="", visible=False),
-				next_btn : gr.Button("Next", interactive=False, visible=False),
-				run_btn : gr.Button(interactive=False),
+				# ------------------Stage1-----------------------
+				desc_md : gr.Markdown(visible=False),# res_md
 				tpl_montage : gr.Image(visible=False),
 				map_montage : gr.Image(value=None, visible=False),
-				res_md : gr.Markdown(visible=False),
+				radio : gr.Radio(choices=[], value=[], label="", visible=False),
+				in_fill_mode : gr.Dropdown(visible=False),
+				chkbox_group : gr.CheckboxGroup(choices=[], value=[], label="", visible=False),
+				fillmode_btn : gr.Button("OK", visible=False),
+				step2_btn : gr.Button("Next", visible=False),
+				step3_btn : gr.Button("Next", visible=False),
+				next_btn : gr.Button("Next step", visible=False),
+				# ------------------Stage2-----------------------
+				run_btn : gr.Button(interactive=False),
 				batch_md : gr.Markdown(visible=False),
 				out_denoised_data : gr.File(visible=False)}
-    	
-	def mapping_result(app_state, channel_info, fill_mode):
 	
-		in_num = len(channel_info["inputByName"])
-		matched_num = 30 - len(channel_info["missingChannelsIndex"])
-		batch_num = math.ceil((in_num-matched_num)/30) + 1
-		app_state.update({
-			"batchCount" : 1,
-			"totalBatchNum" : batch_num
-		})
-		
-		if fill_mode=="mean_manual" and channel_info["missingChannelsIndex"]!=[]:
-			app_state.update({
-				"state" : "initializing",
-				"totalFillingNum" : len(channel_info["missingChannelsIndex"])
-			})
-			#print("Missing channels:", channel_info["missingChannelsIndex"])
-			return {app_state_json : app_state,
-					next_btn : gr.Button(visible=True)}
-		else:
-			app_state.update({
-				"state" : "finished"
-			})
-			return {app_state_json : app_state,
-					res_md : gr.Markdown(visible=True),
-					run_btn : gr.Button(interactive=True)}
-	
-	def show_montage(app_state, channel_info, raw_loc):
-		if app_state["state"] == "selecting":
-			return {app_state_json : app_state} # change nothing
-			
+	# step1
+	def mapping_result(app_state, channel_info, raw_loc):
 		filepath = app_state["filepath"]
+		filename = filepath+"raw_montage_"+str(random.randint(1,10000))+".png"
+		app_state["filenames"]["raw_montage"] = filename
+		
 		raw_montage = read_custom_montage(raw_loc)
+		raw_fig = raw_montage.plot()
+		raw_fig.set_size_inches(5.6, 5.6)
+		raw_fig.savefig(filename, pad_inches=0)
 		
-		# convert all channel names to uppercase
-		for i in range(len(raw_montage.ch_names)):
-			channel = raw_montage.ch_names[i]
-			raw_montage.rename_channels({channel: str.upper(channel)})
-		
-		if app_state["state"] == "initializing":
-			filename = filepath+"raw_montage_"+str(random.randint(1,10000))+".png"
-			app_state["filenames"]["raw_montage"] = filename
-			raw_fig = raw_montage.plot()
-			raw_fig.set_size_inches(5.6, 5.6)
-			raw_fig.savefig(filename, pad_inches=0)
-			
-			return {app_state_json : app_state}
 		
-		elif app_state["state"] == "finished":
-			filename = filepath+"mapped_montage_"+str(random.randint(1,10000))+".png"
-			app_state["filenames"]["map_montage"] = filename
-			
-			show_names= []
-			for channel in channel_info["inputByName"]:
-			    if channel_info["inputByName"][channel]["matched"]:
-			        show_names.append(channel)
-			mapped_fig = raw_montage.plot(show_names=show_names)
-			mapped_fig.set_size_inches(5.6, 5.6)
-			mapped_fig.savefig(filename, pad_inches=0)
+		#################################
+		#### determine the next step ####
+		#################################
+		
+		in_num = len(channel_info["inputByName"])
+		matched_num = 30 - len(channel_info["missingChannels"])
+		
+		# if the input channels(>=30) has all the 30 template channels
+		# -> Stage2.decode data
+		if matched_num == 30:
+			app_state["state"] = "finished"
+			gr.Info('The mapping process is finished!')
 			
 			return {app_state_json : app_state,
+					desc_md : gr.Markdown("### Mapping result", visible=True),
 					tpl_montage : gr.Image(visible=True),
-					map_montage : gr.Image(value=filename, visible=True)}
-					
-		#else:
-			#return {app_state_json : app_state} # change nothing
-	
-	def generate_chkbox(app_state, channel_info):
-		if app_state["state"] == "initializing":
-			in_channels = [channel for channel in channel_info["inputByName"]]
-			app_state["state"] = "selecting"
-			app_state["fillingCount"] = 1
-			
-			idx = channel_info["missingChannelsIndex"][0]
-			name = channel_info["templateByIndex"][idx]
-			chkbox_label = name+' (1/'+str(app_state["totalFillingNum"])+')'
-			return {app_state_json : app_state,
-					chkbox_group : gr.CheckboxGroup(choices=in_channels, label=chkbox_label, visible=True),
-					next_btn : gr.Button(interactive=True)}
-		else:
-			return {app_state_json : app_state} # change nothing
-
-	
-	map_btn.click(
-	    fn = reset1,
-	    inputs = [in_raw_data, in_sample_rate],
-		outputs = [app_state_json, channel_info_json, chkbox_group, next_btn, run_btn,
-					tpl_montage, map_montage, res_md, batch_md, out_denoised_data]
-					
-	).success(
-		fn = mapping_stage1, 
-		inputs = [app_state_json, channel_info_json, in_raw_data, in_raw_loc, in_fill_mode], 
-		outputs = [app_state_json, channel_info_json]
+					map_montage : gr.Image(value=filename, visible=True),
+					run_btn : gr.Button(interactive=True)}
 		
-	).success(
-		fn = mapping_result, 
-		inputs = [app_state_json, channel_info_json, in_fill_mode], 
-		outputs = [app_state_json, next_btn, res_md, run_btn]
+		# if matched channels < 30, and there're still some unmatched input channels
+		# -> assign these input channels to nearby unmatched/empty template channels
+		if in_num > matched_num:
+			app_state["state"] = "step2-initializing"
 		
-	).success(
-		fn = show_montage, 
-		inputs = [app_state_json, channel_info_json, in_raw_loc], 
-		outputs = [app_state_json, tpl_montage, map_montage]
+		# if input channels < 30, but all of them can match to some template channels
+		# -> directly use fill_mode to fill the remaining channels
+		if in_num == matched_num:
+			app_state["state"] = "step3-initializing"
 		
+		return {app_state_json : app_state,
+				desc_md : gr.Markdown("### Mapping result", visible=True),
+				tpl_montage : gr.Image(visible=True),
+				map_montage : gr.Image(value=filename, visible=True),
+				next_btn : gr.Button("Next step", visible=True)}
+	
+	map_btn.click(
+	    fn = reset_all,
+	    inputs = [in_raw_data, in_raw_loc, in_samplerate],
+	    outputs = [app_state_json, channel_info_json, desc_md, tpl_montage, map_montage, radio, in_fill_mode,
+	               chkbox_group, fillmode_btn, step2_btn, step3_btn, next_btn, run_btn, batch_md, out_denoised_data]
 	).success(
-		fn = generate_chkbox, 
-		inputs = [app_state_json, channel_info_json], 
-		outputs = [app_state_json, chkbox_group, next_btn]
-		
+	    fn = mapping_stage1,
+	    inputs = [app_state_json, channel_info_json, in_raw_loc], 
+		outputs = [app_state_json, channel_info_json, desc_md]
+	    
 	).success(
-		fn = None,
-		js = chkbox_js,
-		inputs = [app_state_json, channel_info_json],
-		outputs = []
+	    fn = mapping_result,
+	    inputs = [app_state_json, channel_info_json, in_raw_loc],
+	    outputs = [app_state_json, desc_md, tpl_montage, map_montage, next_btn, run_btn]
 	)
-    
+	
 
-	def check_next(app_state, channel_info, selected, raw_data, fill_mode):
-		#if state["state"] == "selecting":
-			
-		# save info before clicking on next_btn
-		prev_target_idx = channel_info["missingChannelsIndex"][app_state["fillingCount"]-1]
-		prev_target_name = channel_info["templateByIndex"][prev_target_idx]
+	def init_next_step(app_state, channel_info, selected_radio, selected_chkbox):
 		
-		selected_idx = [channel_info["inputByName"][channel]["index"] for channel in selected]
-		app_state["stage1NewOrder"][prev_target_idx] = selected_idx
+		channel_info["missingChannels"] = [channel for channel in channel_info["templateByName"]
+											if channel_info["templateByName"][channel]["matched"]==False]
+		app_state.update({
+			"fillingCount" : 1,
+			"totalFillingNum" : len(channel_info["missingChannels"])
+		})
 		
-		#if len(selected)==1 and channel_info["inputByName"][selected[0]]["used"]==False:
-			#channel_info["inputByName"][selected[0]]["used"] = True
-			#channel_info["missingChannelsIndex"][state["fillingCount"]-1] = -1
+		# step1 -> step2
+		if app_state["state"] == "step2-initializing":
+			app_state["state"] = "step2-selecting"
+			
+			name = channel_info["missingChannels"][0]
+			label = name+' (1/'+str(app_state["totalFillingNum"])+')'
+			
+			unassigned = [channel for channel in channel_info["inputByName"]
+							if channel_info["inputByName"][channel]["assigned"]==False]
+			if len(unassigned)==1 or app_state["totalFillingNum"]==1:
+				btn_label = "Next step"
+			else:
+				btn_label = "Next"
+			
+			return {app_state_json : app_state,
+					channel_info_json : channel_info,
+					desc_md : gr.Markdown("### step2"),
+					tpl_montage : gr.Image(visible=False),
+					map_montage : gr.Image(visible=False),
+					radio : gr.Radio(choices=unassigned, value=[], label=label, visible=True),
+					step2_btn : gr.Button(btn_label, visible=True),
+					next_btn : gr.Button(visible=False)}
 		
-		print('Selection for missing channel "{}"({}): {}'.format(prev_target_name, prev_target_idx, selected))
+		# step1 -> step3
+		elif app_state["state"] == "step3-initializing":
+			
+			return {app_state_json : app_state,
+					desc_md : gr.Markdown("### step3"),
+					tpl_montage : gr.Image(visible=False),
+					map_montage : gr.Image(visible=False),
+					in_fill_mode : gr.Dropdown(visible=True),
+					fillmode_btn : gr.Button(visible=True),
+					next_btn : gr.Button(visible=False)}
 		
-		# update next round
-		app_state["fillingCount"] += 1
+		# step2 -> step3/Stage2.decode data
+		elif app_state["state"] == "step2-selecting":
 		
-		if app_state["fillingCount"] <= app_state["totalFillingNum"]:
-			target_idx = channel_info["missingChannelsIndex"][app_state["fillingCount"]-1]
-			target_name = channel_info["templateByIndex"][target_idx]
+			# save info before clicking on next_btn
+			if selected_radio != []:
+				prev_target_name = channel_info["missingChannels"][app_state["fillingCount"]-1]
+				prev_target_idx = channel_info["templateByName"][prev_target_name]["index"]
+				
+				selected_idx = channel_info["inputByName"][selected_radio]["index"]
+				app_state["stage1NewOrder"][prev_target_idx] = [selected_idx]
 			
-			chkbox_label = target_name+' ('+str(app_state["fillingCount"])+'/'+str(app_state["totalFillingNum"])+')'
-			btn_label = "Submit" if app_state["fillingCount"]==app_state["totalFillingNum"] else "Next"
+				channel_info["templateByName"][prev_target_name]["matched"] = True
+				channel_info["inputByName"][selected_radio]["assigned"] = True
+				print(prev_target_name, '<-', selected_radio)
 			
-			return {app_state_json : app_state,
-					#channel_info_json : channel_info,
-					chkbox_group : gr.CheckboxGroup(value=[], label=chkbox_label),
-					next_btn : gr.Button(btn_label)}
-		else:
+			# if all the unmatched template channels were filled by input channels
+			# -> Stage2
+			if app_state["fillingCount"] == app_state["totalFillingNum"]:
+				app_state["state"] = "finished"
+				gr.Info('The mapping process is finished!')
+				
+				return {app_state_json : app_state,
+						channel_info_json : channel_info,
+						desc_md : gr.Markdown(visible=False),
+						radio : gr.Radio(visible=False),
+						next_btn : gr.Button(visible=False),
+						run_btn : gr.Button(interactive=True)}
+						
+			# -> step3
+			else:
+				app_state["state"] = "step3-initializing"
+				
+				return {app_state_json : app_state,
+						channel_info_json : channel_info,
+						desc_md : gr.Markdown("### step3"),
+						radio : gr.Radio(visible=False),
+						in_fill_mode : gr.Dropdown(visible=True),
+						fillmode_btn : gr.Button(visible=True),
+						next_btn : gr.Button(visible=False)}
+		
+		# step3 -> Stage2.decode data
+		elif app_state["state"] == "step3-selecting":
 			app_state["state"] = "finished"
+			gr.Info('The mapping process is finished!')
+			
+			# save info before clicking on next_btn
+			if selected_chkbox != []:
+				prev_target_name = channel_info["missingChannels"][app_state["fillingCount"]-1]
+				prev_target_idx = channel_info["templateByName"][prev_target_name]["index"]
+				
+				selected_idx = [channel_info["inputByName"][channel]["index"] for channel in selected_chkbox]
+				app_state["stage1NewOrder"][prev_target_idx] = selected_idx
+				
+				#print('Selection for missing channel "{}"({}): {}'.format(prev_target_name, prev_target_idx, selected))
 			
 			return {app_state_json : app_state,
-					#channel_info_json : channel_info,
+					desc_md : gr.Markdown(visible=False),
 					chkbox_group : gr.CheckboxGroup(visible=False),
 					next_btn : gr.Button(visible=False),
-					res_md : gr.Markdown(visible=True),
 					run_btn : gr.Button(interactive=True)}
 	
 	next_btn.click(
-	    fn = check_next,
-	    inputs = [app_state_json, channel_info_json, chkbox_group, in_raw_data, in_fill_mode],
-	    outputs = [app_state_json, chkbox_group, next_btn, run_btn, res_md]
+		fn = init_next_step,
+		inputs = [app_state_json, channel_info_json, radio, chkbox_group],
+		outputs = [app_state_json, channel_info_json, desc_md, tpl_montage, map_montage, radio, in_fill_mode,
+					chkbox_group, fillmode_btn, step2_btn, next_btn, run_btn]
+	).success(
+	    fn = None,
+	    js = indication_js,
+	    inputs = [app_state_json, channel_info_json],
+		outputs = []
+	)
 	
+	# step2
+	# def update_selection()
+	def update_radio(app_state, channel_info, selected):
+		
+		# save info before clicking on next_btn
+		if selected != []:
+			prev_target_name = channel_info["missingChannels"][app_state["fillingCount"]-1]
+			prev_target_idx = channel_info["templateByName"][prev_target_name]["index"]
+			
+			selected_idx = channel_info["inputByName"][selected]["index"]
+			app_state["stage1NewOrder"][prev_target_idx] = [selected_idx]
+		
+			channel_info["templateByName"][prev_target_name]["matched"] = True
+			channel_info["inputByName"][selected]["assigned"] = True
+			print(prev_target_name, '<-', selected)
+		
+		# update the current round
+		app_state["fillingCount"] += 1
+		unassigned = [channel for channel in channel_info["inputByName"]
+						if channel_info["inputByName"][channel]["assigned"]==False]
+		
+		target_name = channel_info["missingChannels"][app_state["fillingCount"]-1]
+				
+		radio_label = target_name+' ('+str(app_state["fillingCount"])+'/'+str(app_state["totalFillingNum"])+')'
+				
+		if len(unassigned)==1 or app_state["fillingCount"]==app_state["totalFillingNum"]:
+			return {app_state_json : app_state,
+					channel_info_json : channel_info,
+					radio : gr.Radio(choices=unassigned, value=[], label=radio_label),
+					step2_btn : gr.Button(visible=False),
+					next_btn : gr.Button("Next step", visible=True)}
+		else:
+			return {app_state_json : app_state,
+					channel_info_json : channel_info,
+					radio : gr.Radio(choices=unassigned, value=[], label=radio_label)}
+	
+	step2_btn.click(
+	    fn = update_radio,
+	    inputs = [app_state_json, channel_info_json, radio],
+	    outputs = [app_state_json, channel_info_json, radio, step2_btn, next_btn]
+	    
 	).success(
-	    fn = show_montage,
-	    inputs = [app_state_json, channel_info_json, in_raw_loc],
-		outputs = [app_state_json, tpl_montage, map_montage]
+	    fn = None,
+	    js = indication_js,
+	    inputs = [app_state_json, channel_info_json],
+		outputs = []
+	)
+	
+	# step3
+	@fillmode_btn.click(inputs = [app_state_json, channel_info_json, in_fill_mode],
+						outputs = [app_state_json, in_fill_mode, fillmode_btn, chkbox_group, step3_btn, run_btn])
+	def fill_value(app_state, channel_info, fill_mode):
+		
+		if fill_mode == 'zero':
+			app_state["state"] = "finished"
+			gr.Info('The mapping process is finished!')
+			
+			return {app_state_json : app_state,
+					desc_md : gr.Markdown(visible=False),
+					in_fill_mode : gr.Dropdown(visible=False),
+					fillmode_btn : gr.Button(visible=False),
+					run_btn : gr.Button(interactive=True)}
+		
+		elif fill_mode == 'mean':
+			app_state["state"] = "step3-selecting"
+			app_state = find_neighbors(app_state, channel_info, fill_mode)
+			
+			name = channel_info["missingChannels"][0]
+			idx = channel_info["templateByName"][name]["index"]
+			value = app_state["stage1NewOrder"][idx]
+			value = [channel_info["inputByIndex"][i] for i in value]
+			label = name+' (1/'+str(app_state["totalFillingNum"])+')'
+			
+			return {app_state_json : app_state,
+					in_fill_mode : gr.Dropdown(visible=False),
+		    		fillmode_btn : gr.Button(visible=False),
+		    		chkbox_group : gr.CheckboxGroup(choices=channel_info["inputByIndex"],
+													value=value, label=label, visible=True),
+		            step3_btn : gr.Button(visible=True)}
+	
+	def update_chkbox(app_state, channel_info, selected):
+	
+		# save info before clicking on next_btn
+		if selected != []:
+			prev_target_name = channel_info["missingChannels"][app_state["fillingCount"]-1]
+			prev_target_idx = channel_info["templateByName"][prev_target_name]["index"]
+			
+			selected_idx = [channel_info["inputByName"][channel]["index"] for channel in selected]
+			app_state["stage1NewOrder"][prev_target_idx] = selected_idx
+			
+			#print('Selection for missing channel "{}"({}): {}'.format(prev_target_name, prev_target_idx, selected))
 		
+		# update next round
+		app_state["fillingCount"] += 1
+		
+		target_name = channel_info["missingChannels"][app_state["fillingCount"]-1]
+		target_idx = channel_info["templateByName"][target_name]["index"]
+		
+		chkbox_value = app_state["stage1NewOrder"][target_idx]
+		chkbox_value = [channel_info["inputByIndex"][i] for i in chkbox_value]
+		chkbox_label = target_name+' ('+str(app_state["fillingCount"])+'/'+str(app_state["totalFillingNum"])+')'
+		
+		if app_state["fillingCount"] == app_state["totalFillingNum"]:
+			return {app_state_json : app_state,
+					chkbox_group : gr.CheckboxGroup(value=chkbox_value, label=chkbox_label),
+					step3_btn : gr.Button(visible=False),
+					next_btn : gr.Button("Submit", visible=True)}
+		else:
+			return {app_state_json : app_state,
+					chkbox_group : gr.CheckboxGroup(value=chkbox_value, label=chkbox_label)}
+	
+	step3_btn.click(
+	    fn = update_chkbox,
+	    inputs = [app_state_json, channel_info_json, chkbox_group],
+	    outputs = [app_state_json, chkbox_group, step3_btn, next_btn]
+	    
 	).success(
-		fn = None,
-		js = indication_js,
-		inputs = [app_state_json, channel_info_json],
+	    fn = None,
+	    js = indication_js,
+	    inputs = [app_state_json, channel_info_json],
 		outputs = []
 	)
 	
+
 	def delete_file(filename):
 		try:
 			os.remove(filename)
 		except OSError as e:
 			print(e)
 	
-	def reset2(app_state, raw_data, model_name):
+	def reset_run(app_state, channel_info, raw_data, model_name):
 		filepath = app_state["filepath"]
 		input_name = os.path.basename(str(raw_data))
 		output_name = os.path.splitext(input_name)[0]+'_'+model_name+'.csv'
 		
+		in_num = len(channel_info["inputByName"])
+		matched_num = len([channel for channel in channel_info["inputByName"]
+							if channel_info["inputByName"][channel]["matched"]==True])
+		batch_num = math.ceil((in_num-matched_num)/30) + 1
+		
 		app_state["filenames"]["denoised"] = filepath + output_name
 		app_state.update({
 			"runnigState" : "stage1",
 			"batchCount" : 1,
+			"totalBatchNum" : batch_num,
 			"stage2NewOrder" : [[]]*30
 		})
 		
@@ -491,7 +645,6 @@ with gr.Blocks() as demo:
 				app_state, channel_info = mapping_stage2(app_state, channel_info, fill_mode)
 				if app_state["runnigState"] == "finished":
 					break
-			app_state["batchCount"] += 1
 			
 			reorder_to_template(app_state, raw_data)
 			# step1: Data preprocessing
@@ -507,14 +660,15 @@ with gr.Blocks() as demo:
 			
 			delete_file(filepath+'mapped.csv')
 			delete_file(filepath+'denoised.csv')
+			app_state["batchCount"] += 1
 			
 		yield {run_btn : gr.Button(interactive=True),
 				batch_md : gr.Markdown(visible=False),
 				out_denoised_data : gr.File(new_filename, visible=True)}
 	
 	run_btn.click(
-		fn = reset2,
-		inputs = [app_state_json, in_raw_data, in_model_name],
+		fn = reset_run,
+		inputs = [app_state_json, channel_info_json, in_raw_data, in_model_name],
 		outputs = [app_state_json, run_btn, batch_md, out_denoised_data]
 		
 	).success(
@@ -524,4 +678,4 @@ with gr.Blocks() as demo:
 	)
 	
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(server_name="0.0.0.0", server_port=7860)

channel_mapping.py

@@ -15,8 +15,8 @@ def reorder_to_template(app_state, filename):
 	old_data = utils.read_train_data(filename) # original raw data
 	new_data = np.zeros((30, old_data.shape[1])) # reordered raw data
 	new_filename = app_state["filepath"]+'mapped.csv'
-	#print('new order 1:', app_state["stage1NewOrder"])
-	#print('new order 2:', app_state["stage2NewOrder"])
+	print('new order 1:', app_state["stage1NewOrder"])
+	print('new order 2:', app_state["stage2NewOrder"])
 	
 	zero_arr = np.zeros((1, old_data.shape[1]))
 	old_data = np.concatenate((old_data, zero_arr), axis=0)
@@ -96,7 +96,7 @@ def align_coords(channel_info, template_montage, input_montage):
 	input_order = channel_info["inputByIndex"]
 	matched = [channel for channel in input_dict if input_dict[channel]["matched"]==True]
 	
-	# 2-d (fot the indication of missing template channel's position when fill_mode:'mean_manual')
+	# 2-d (for the indication of missing template channel's position when fill_mode:'mean_manual')
 	fig = [template_montage.plot(), input_montage.plot()]
 	fig[0].set_size_inches(5.6, 5.6)
 	fig[1].set_size_inches(5.6, 5.6)
@@ -161,39 +161,33 @@ def align_coords(channel_info, template_montage, input_montage):
 	})
 	return channel_info
 
-def fill_channels(app_state, channel_info, fill_mode):
-
+def find_neighbors(app_state, channel_info, fill_mode):
 	new_idx = app_state["stage1NewOrder"] if app_state["runnigState"]=="stage1" else app_state["stage2NewOrder"]
 	template_dict = channel_info["templateByName"]
 	input_dict = channel_info["inputByName"]
 	template_order = channel_info["templateByIndex"]
 	input_order = channel_info["inputByIndex"]
-	z_row_idx = channel_info["dataShape"][0]
+	#z_row_idx = channel_info["dataShape"][0]
 	unmatched = [channel for channel in template_dict if template_dict[channel]["matched"]==False]
 	if unmatched == []:
-		return app_state
+		return app_state # change mothing
 	
-	if fill_mode == 'zero':
-		for channel in unmatched:
-			idx = template_dict[channel]["index"]
-			new_idx[idx] = [z_row_idx]
 	
-	elif fill_mode == 'mean_auto':
-		# use KNN to choose k nearest channels
-		in_coords = [input_dict[channel]["coord"] for channel in input_order]
-		in_coords = np.array([in_coords[i] for i in range(len(in_coords))])
-		
-		k = 4 if len(input_dict)>4 else len(input_dict)
-		knn = NearestNeighbors(n_neighbors=k, metric='euclidean')
-		knn.fit(in_coords)
+	in_coords = [input_dict[channel]["coord"] for channel in input_order]
+	in_coords = np.array([in_coords[i] for i in range(len(in_coords))])
+	
+	# use KNN to choose k nearest channels
+	k = 4 if len(input_dict)>4 else len(input_dict)
+	knn = NearestNeighbors(n_neighbors=k, metric='euclidean')
+	knn.fit(in_coords)
+	
+	for channel in unmatched:
+		distances, indices = knn.kneighbors(np.array(template_dict[channel]["coord"]).reshape(1,-1))
+		selected = [input_order[i] for i in indices[0]]
+		print(channel, ':', selected)
 		
-		for channel in unmatched:
-			distances, indices = knn.kneighbors(np.array(template_dict[channel]["coord"]).reshape(1,-1))
-			selected = [input_order[i] for i in indices[0]]
-			print(channel, ':', selected)
-			
-			idx = template_dict[channel]["index"]
-			new_idx[idx] = indices[0].tolist()
+		idx = template_dict[channel]["index"]
+		new_idx[idx] = indices[0].tolist()
 	
 	if app_state["runnigState"] == "stage1":
 		app_state["stage1NewOrder"] = new_idx
@@ -202,7 +196,8 @@ def fill_channels(app_state, channel_info, fill_mode):
     
 	return app_state
 
-def mapping_stage1(app_state, channel_info, data_file, loc_file, fill_mode):
+def mapping_stage1(app_state, channel_info, loc_file):
+	yield app_state, channel_info, gr.Markdown("Mapping...", visible=True) # app_state, channel_info???
 	second1 = time.time()
 	
 	template_montage, input_montage, template_dict, input_dict = read_montage_data(loc_file)
@@ -233,10 +228,10 @@ def mapping_stage1(app_state, channel_info, data_file, loc_file, fill_mode):
 			input_dict[channel].matched = True
 			input_dict[channel].assigned = True
 		else:
-			missing_channels.append(i)
+			missing_channels.append(channel)
 	
 	channel_info.update({
-	    "missingChannelsIndex" : missing_channels,
+	    "missingChannels" : missing_channels,
 	    "templateByName" : {k : v.__dict__ for k,v in template_dict.items()},
 	    "inputByName" : {k : v.__dict__ for k,v in input_dict.items()},
 	    "templateByIndex" : template_montage.ch_names,
@@ -250,11 +245,11 @@ def mapping_stage1(app_state, channel_info, data_file, loc_file, fill_mode):
 	# align input, template's coordinates
 	channel_info = align_coords(channel_info, template_montage, input_montage)
 	# fill the unmatched channels
-	app_state = fill_channels(app_state, channel_info, fill_mode)
+	#app_state = fill_channels(app_state, channel_info, fill_mode)
 	
 	second2 = time.time()
 	print('Mapping (stage1) finished in',second2 - second1,'s.')
-	return app_state, channel_info
+	yield app_state, channel_info, gr.Markdown("", visible=False)
 
 def mapping_stage2(app_state, channel_info, fill_mode):
 	second1 = time.time()
@@ -311,7 +306,7 @@ def mapping_stage2(app_state, channel_info, fill_mode):
 	})
 	
 	# fill the unmatched channels
-	app_state = fill_channels(app_state, channel_info, fill_mode)
+	app_state = find_neighbors(app_state, channel_info, fill_mode)
 	
 	second2 = time.time()
 	print(f'Mapping (stage2-{app_state["batchCount"]-1}) finished in {second2 - second1}s.')